 @@ -1,1837 +1,1860 @@
-/*	$NetBSD: zic.c,v 1.63 2016/10/07 15:29:42 christos Exp $	*/
+/*	$NetBSD: zic.c,v 1.64 2016/10/07 19:47:16 kre Exp $	*/
 /*
 ** This file is in the public domain, so clarified as of
 ** 2006-07-17 by Arthur David Olson.
 */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: zic.c,v 1.63 2016/10/07 15:29:42 christos Exp $");
+__RCSID("$NetBSD: zic.c,v 1.64 2016/10/07 19:47:16 kre Exp $");
 #endif /* !defined lint */
 #include "private.h"
 #include "locale.h"
 #include "tzfile.h"
 #include <stdarg.h>
 #include <unistd.h>
 #include <util.h>
 #define	ZIC_VERSION_PRE_2013 '2'
 #define	ZIC_VERSION	'3'
 typedef int_fast64_t	zic_t;
 #define ZIC_MIN INT_FAST64_MIN
 #define ZIC_MAX INT_FAST64_MAX
 #define SCNdZIC SCNdFAST64
 #ifndef ZIC_MAX_ABBR_LEN_WO_WARN
 #define ZIC_MAX_ABBR_LEN_WO_WARN	6
 #endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */
 #ifdef HAVE_DIRECT_H
 # include <direct.h>
 # include <io.h>
 # undef mkdir
 # define mkdir(name, mode) _mkdir(name)
 #endif
 #if HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 #ifdef S_IRUSR
 #define MKDIR_UMASK (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
 #else
 #define MKDIR_UMASK 0755
 #endif
 struct rule {
 	const char *	r_filename;
 	int		r_linenum;
 	const char *	r_name;
 	zic_t		r_loyear;	/* for example, 1986 */
 	zic_t		r_hiyear;	/* for example, 1986 */
 	const char *	r_yrtype;
 	bool		r_lowasnum;
 	bool		r_hiwasnum;
 	int		r_month;	/* 0..11 */
 	int		r_dycode;	/* see below */
 	int		r_dayofmonth;
 	int		r_wday;
 	zic_t		r_tod;		/* time from midnight */
 	bool		r_todisstd;	/* above is standard time if 1 */
 					/* or wall clock time if 0 */
 	bool		r_todisgmt;	/* above is GMT if 1 */
 					/* or local time if 0 */
 	zic_t		r_stdoff;	/* offset from standard time */
 	const char *	r_abbrvar;	/* variable part of abbreviation */
 	int		r_todo;		/* a rule to do (used in outzone) */
 	zic_t		r_temp;		/* used in outzone */
 };
 /*
 **	r_dycode		r_dayofmonth	r_wday
 */
 #define DC_DOM		0	/* 1..31 */	/* unused */
 #define DC_DOWGEQ	1	/* 1..31 */	/* 0..6 (Sun..Sat) */
 #define DC_DOWLEQ	2	/* 1..31 */	/* 0..6 (Sun..Sat) */
 struct zone {
 	const char *	z_filename;
 	int		z_linenum;
 	const char *	z_name;
 	zic_t		z_gmtoff;
 	const char *	z_rule;
 	const char *	z_format;
 	char		z_format_specifier;
 	zic_t		z_stdoff;
 	struct rule *	z_rules;
 	int		z_nrules;
 	struct rule	z_untilrule;
 	zic_t		z_untiltime;
 };
 #if !HAVE_POSIX_DECLS
 extern int	getopt(int argc, char * const argv[],
 			const char * options);
 extern int	link(const char * fromname, const char * toname);
 extern char *	optarg;
 extern int	optind;
 #endif
 #if ! HAVE_LINK
 # define link(from, to) (errno = ENOTSUP, -1)
 #endif
 #if ! HAVE_SYMLINK
 # define lstat(name, st) stat(name, st)
 # define symlink(from, to) (errno = ENOTSUP, -1)
 # define S_ISLNK(m) 0
 #endif
 static void	addtt(zic_t starttime, int type);
 static int	addtype(zic_t, char const *, bool, bool, bool);
 static void	leapadd(zic_t, bool, int, int);
 static void	adjleap(void);
 static void	associate(void);
 static void	dolink(const char *, const char *, bool);
 static char **	getfields(char * buf);
 static zic_t	gethms(const char * string, const char * errstring,
 			bool);
 static void	infile(const char * filename);
 static void	inleap(char ** fields, int nfields);
 static void	inlink(char ** fields, int nfields);
 static void	inrule(char ** fields, int nfields);
 static bool	inzcont(char ** fields, int nfields);
 static bool	inzone(char ** fields, int nfields);
 static bool	inzsub(char **, int, int);
 static int	itsdir(const char * name);
 static bool	is_alpha(char a);
 static char	lowerit(char);
 static void	mkdirs(char const *, bool);
 static void	newabbr(const char * abbr);
 static zic_t	oadd(zic_t t1, zic_t t2);
 static void	outzone(const struct zone * zp, int ntzones);
 static zic_t	rpytime(const struct rule * rp, zic_t wantedy);
 static void	rulesub(struct rule * rp,
 			const char * loyearp, const char * hiyearp,
 			const char * typep, const char * monthp,
 			const char * dayp, const char * timep);
 static zic_t	tadd(zic_t t1, zic_t t2);
 static bool	yearistype(int year, const char * type);
 /* Bound on length of what %z can expand to.  */
 enum { PERCENT_Z_LEN_BOUND = sizeof "+995959" - 1 };
 /* If true, work around a bug in Qt 5.6.1 and earlier, which mishandles
    tz binary files whose POSIX-TZ-style strings contain '<'; see
    QTBUG-53071 <https://bugreports.qt.io/browse/QTBUG-53071>.  This
    workaround will no longer be needed when Qt 5.6.1 and earlier are
    obsolete, say in the year 2021.  */
 enum { WORK_AROUND_QTBUG_53071 = 1 };
 static int		charcnt;
 static bool		errors;
 static bool		warnings;
 static const char *	filename;
 static int		leapcnt;
 static bool		leapseen;
 static zic_t		leapminyear;
 static zic_t		leapmaxyear;
 static int		linenum;
 static size_t		max_abbrvar_len = PERCENT_Z_LEN_BOUND;
 static size_t		max_format_len;
 static zic_t		max_year;
 static zic_t		min_year;
 static bool		noise;
 static const char *	rfilename;
 static int		rlinenum;
 static const char *	progname;
 static int		timecnt;
 static int		timecnt_alloc;
 static int		typecnt;
 /*
 ** Line codes.
 */
 #define LC_RULE		0
 #define LC_ZONE		1
 #define LC_LINK		2
 #define LC_LEAP		3
 /*
 ** Which fields are which on a Zone line.
 */
 #define ZF_NAME		1
 #define ZF_GMTOFF	2
 #define ZF_RULE		3
 #define ZF_FORMAT	4
 #define ZF_TILYEAR	5
 #define ZF_TILMONTH	6
 #define ZF_TILDAY	7
 #define ZF_TILTIME	8
 #define ZONE_MINFIELDS	5
 #define ZONE_MAXFIELDS	9
 /*
 ** Which fields are which on a Zone continuation line.
 */
 #define ZFC_GMTOFF	0
 #define ZFC_RULE	1
 #define ZFC_FORMAT	2
 #define ZFC_TILYEAR	3
 #define ZFC_TILMONTH	4
 #define ZFC_TILDAY	5
 #define ZFC_TILTIME	6
 #define ZONEC_MINFIELDS	3
 #define ZONEC_MAXFIELDS	7
 /*
 ** Which files are which on a Rule line.
 */
 #define RF_NAME		1
 #define RF_LOYEAR	2
 #define RF_HIYEAR	3
 #define RF_COMMAND	4
 #define RF_MONTH	5
 #define RF_DAY		6
 #define RF_TOD		7
 #define RF_STDOFF	8
 #define RF_ABBRVAR	9
 #define RULE_FIELDS	10
 /*
 ** Which fields are which on a Link line.
 */
 #define LF_FROM		1
 #define LF_TO		2
 #define LINK_FIELDS	3
 /*
 ** Which fields are which on a Leap line.
 */
 #define LP_YEAR		1
 #define LP_MONTH	2
 #define LP_DAY		3
 #define LP_TIME		4
 #define LP_CORR		5
 #define LP_ROLL		6
 #define LEAP_FIELDS	7
 /*
 ** Year synonyms.
 */
 #define YR_MINIMUM	0
 #define YR_MAXIMUM	1
 #define YR_ONLY		2
 static struct rule *	rules;
 static int		nrules;	/* number of rules */
 static int		nrules_alloc;
 static struct zone *	zones;
 static int		nzones;	/* number of zones */
 static int		nzones_alloc;
 struct link {
 	const char *	l_filename;
 	int		l_linenum;
 	const char *	l_from;
 	const char *	l_to;
 };
 static struct link *	links;
 static int		nlinks;
 static int		nlinks_alloc;
 struct lookup {
 	const char *	l_word;
 	const int	l_value;
 };
 static struct lookup const *	byword(const char * string,
 					const struct lookup * lp);
 static struct lookup const	line_codes[] = {
 	{ "Rule",	LC_RULE },
 	{ "Zone",	LC_ZONE },
 	{ "Link",	LC_LINK },
 	{ "Leap",	LC_LEAP },
 	{ NULL,		0}
 };
 static struct lookup const	mon_names[] = {
 	{ "January",	TM_JANUARY },
 	{ "February",	TM_FEBRUARY },
 	{ "March",	TM_MARCH },
 	{ "April",	TM_APRIL },
 	{ "May",	TM_MAY },
 	{ "June",	TM_JUNE },
 	{ "July",	TM_JULY },
 	{ "August",	TM_AUGUST },
 	{ "September",	TM_SEPTEMBER },
 	{ "October",	TM_OCTOBER },
 	{ "November",	TM_NOVEMBER },
 	{ "December",	TM_DECEMBER },
 	{ NULL,		0 }
 };
 static struct lookup const	wday_names[] = {
 	{ "Sunday",	TM_SUNDAY },
 	{ "Monday",	TM_MONDAY },
 	{ "Tuesday",	TM_TUESDAY },
 	{ "Wednesday",	TM_WEDNESDAY },
 	{ "Thursday",	TM_THURSDAY },
 	{ "Friday",	TM_FRIDAY },
 	{ "Saturday",	TM_SATURDAY },
 	{ NULL,		0 }
 };
 static struct lookup const	lasts[] = {
 	{ "last-Sunday",	TM_SUNDAY },
 	{ "last-Monday",	TM_MONDAY },
 	{ "last-Tuesday",	TM_TUESDAY },
 	{ "last-Wednesday",	TM_WEDNESDAY },
 	{ "last-Thursday",	TM_THURSDAY },
 	{ "last-Friday",	TM_FRIDAY },
 	{ "last-Saturday",	TM_SATURDAY },
 	{ NULL,			0 }
 };
 static struct lookup const	begin_years[] = {
 	{ "minimum",	YR_MINIMUM },
 	{ "maximum",	YR_MAXIMUM },
 	{ NULL,		0 }
 };
 static struct lookup const	end_years[] = {
 	{ "minimum",	YR_MINIMUM },
 	{ "maximum",	YR_MAXIMUM },
 	{ "only",	YR_ONLY },
 	{ NULL,		0 }
 };
 static struct lookup const	leap_types[] = {
 	{ "Rolling",	true },
 	{ "Stationary",	false },
 	{ NULL,		0 }
 };
 static const int	len_months[2][MONSPERYEAR] = {
 	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
 	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
 };
 static const int	len_years[2] = {
 	DAYSPERNYEAR, DAYSPERLYEAR
 };
 static struct attype {
 	zic_t		at;
 	bool		dontmerge;
 	unsigned char	type;
 } *			attypes;
 static zic_t		gmtoffs[TZ_MAX_TYPES];
 static char		isdsts[TZ_MAX_TYPES];
 static unsigned char	abbrinds[TZ_MAX_TYPES];
 static bool		ttisstds[TZ_MAX_TYPES];
 static bool		ttisgmts[TZ_MAX_TYPES];
 static char		chars[TZ_MAX_CHARS];
 static zic_t		trans[TZ_MAX_LEAPS];
 static zic_t		corr[TZ_MAX_LEAPS];
 static char		roll[TZ_MAX_LEAPS];
 /*
 ** Memory allocation.
 */
 static _Noreturn void
 memory_exhausted(const char *msg)
+{
 	fprintf(stderr, _("%s: Memory exhausted: %s\n"), progname, msg);
 	exit(EXIT_FAILURE);
+}
 static ATTRIBUTE_PURE size_t
 size_product(size_t nitems, size_t itemsize)
+{
 	if (SIZE_MAX / itemsize < nitems)
 		memory_exhausted(_("size overflow"));
 	return nitems * itemsize;
+}
 #if !HAVE_STRDUP
 static char *
 strdup(char const *str)
+{
 	char *result = malloc(strlen(str) + 1);
 	return result ? strcpy(result, str) : result;
+}
 #endif
 static ATTRIBUTE_PURE void *
 memcheck(void *ptr)
+{
 	if (ptr == NULL)
 		memory_exhausted(strerror(errno));
 	return ptr;
+}
 static void *
 zic_malloc(size_t size)
+{
 	return memcheck(malloc(size));
+}
 static void *
 zic_realloc(void *ptr, size_t size)
+{
 	return memcheck(realloc(ptr, size));
+}
 static char *
 ecpyalloc(char const *str)
+{
 	return memcheck(strdup(str));
+}
 static void *
 growalloc(void *ptr, size_t itemsize, int nitems, int *nitems_alloc)
+{
 	if (nitems < *nitems_alloc)
 		return ptr;
 	else {
 #define IMAX (INT_MAX < SIZE_MAX ? INT_MAX : (int)SIZE_MAX)
 		int nitems_max = IMAX - WORK_AROUND_QTBUG_53071;
 		int amax = nitems_max < IMAX ? nitems_max : IMAX;
 		if ((amax - 1) / 3 * 2 < *nitems_alloc)
 			memory_exhausted(_("int overflow"));
 		*nitems_alloc = *nitems_alloc + (*nitems_alloc >> 1) + 1;
 		return zic_realloc(ptr, size_product(*nitems_alloc, itemsize));
+	}
+}
 /*
 ** Error handling.
 */
 static void
 eats(const char *const name, const int num, const char *const rname,
     const int rnum)
+{
 	filename = name;
 	linenum = num;
 	rfilename = rname;
 	rlinenum = rnum;
+}
 static void
 eat(const char *const name, const int num)
+{
 	eats(name, num, NULL, -1);
+}
 static void ATTRIBUTE_FORMAT((printf, 1, 0))
 verror(const char *const string, va_list args)
+{
 	/*
 	** Match the format of "cc" to allow sh users to
 	**	zic ... 2>&1 | error -t "*" -v
 	** on BSD systems.
 	*/
 	if (filename)
 	  fprintf(stderr, _("\"%s\", line %d: "), filename, linenum);
 	vfprintf(stderr, string, args);
 	if (rfilename != NULL)
 		fprintf(stderr, _(" (rule from \"%s\", line %d)"),
 			rfilename, rlinenum);
 	fprintf(stderr, "\n");
+}
 static void ATTRIBUTE_FORMAT((printf, 1, 2))
 error(const char *const string, ...)
+{
 	va_list args;
 	va_start(args, string);
 	verror(string, args);
 	va_end(args);
 	errors = true;
+}
 static void ATTRIBUTE_FORMAT((printf, 1, 2))
 warning(const char *const string, ...)
+{
 	va_list args;
 	fprintf(stderr, _("warning: "));
 	va_start(args, string);
 	verror(string, args);
 	va_end(args);
 	warnings = true;
+}
 static void
 close_file(FILE *stream, char const *dir, char const *name)
+{
   char const *e = (ferror(stream) ? _("I/O error")
 		   : fclose(stream) != 0 ? strerror(errno) : NULL);
   if (e) {
     fprintf(stderr, "%s: %s%s%s%s%s\n", progname,
 	    dir ? dir : "", dir ? "/" : "",
 	    name ? name : "", name ? ": " : "",
 	    e);
     exit(EXIT_FAILURE);
+  }
+}
 static _Noreturn void
 usage(FILE *stream, int status)
+{
   fprintf(stream,
 	  _("%s: usage is %s [ --version ] [ --help ] [ -v ] \\\n"
 	    "\t[ -l localtime ] [ -p posixrules ] [ -d directory ] \\\n"
 	    "\t[ -L leapseconds ] [ filename ... ]\n\n"
 	    "Report bugs to %s.\n"),
 	  progname, progname, REPORT_BUGS_TO);
   if (status == EXIT_SUCCESS)
     close_file(stream, NULL, NULL);
   exit(status);
+}
 /* Change the working directory to DIR, possibly creating DIR and its
    ancestors.  After this is done, all files are accessed with names
    relative to DIR.  */
 static void
 change_directory (char const *dir)
+{
   if (chdir(dir) != 0) {
     int chdir_errno = errno;
     if (chdir_errno == ENOENT) {
       mkdirs(dir, false);
       chdir_errno = chdir(dir) == 0 ? 0 : errno;
+    }
     if (chdir_errno != 0) {
       fprintf(stderr, _("%s: Can't chdir to %s: %s\n"),
 	      progname, dir, strerror(chdir_errno));
       exit(EXIT_FAILURE);
+    }
+  }
+}
 static const char *	psxrules;
 static const char *	lcltime;
 static const char *	directory;
 static const char *	leapsec;
 static const char *	yitcommand;
 int
 main(int argc, char **argv)
+{
 	int	i;
 	int	j;
 	int	c;
 #ifdef S_IWGRP
 	umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
 #endif
 #if HAVE_GETTEXT
 	setlocale(LC_MESSAGES, "");
 #ifdef TZ_DOMAINDIR
 	bindtextdomain(TZ_DOMAIN, TZ_DOMAINDIR);
 #endif /* defined TEXTDOMAINDIR */
 	textdomain(TZ_DOMAIN);
 #endif /* HAVE_GETTEXT */
 	progname = argv[0];
 	if (TYPE_BIT(zic_t) < 64) {
 		fprintf(stderr, "%s: %s\n", progname,
 			_("wild compilation-time specification of zic_t"));
 		return EXIT_FAILURE;
+	}
 	for (i = 1; i < argc; ++i)
 		if (strcmp(argv[i], "--version") == 0) {
 			printf("zic %s%s\n", PKGVERSION, TZVERSION);
 			close_file(stdout, NULL, NULL);
 			return EXIT_SUCCESS;
 		} else if (strcmp(argv[i], "--help") == 0) {
 			usage(stdout, EXIT_SUCCESS);
+		}
 	while ((c = getopt(argc, argv, "d:l:p:L:vsy:")) != EOF && c != -1)
 		switch (c) {
 			default:
 				usage(stderr, EXIT_FAILURE);
 			case 'd':
 				if (directory == NULL)
 					directory = optarg;
 				else {
 					fprintf(stderr,
 _("%s: More than one -d option specified\n"),
 						progname);
 					return EXIT_FAILURE;
+				}
 				break;
 			case 'l':
 				if (lcltime == NULL)
 					lcltime = optarg;
 				else {
 					fprintf(stderr,
 _("%s: More than one -l option specified\n"),
 						progname);
 					return EXIT_FAILURE;
+				}
 				break;
 			case 'p':
 				if (psxrules == NULL)
 					psxrules = optarg;
 				else {
 					fprintf(stderr,
 _("%s: More than one -p option specified\n"),
 						progname);
 					return EXIT_FAILURE;
+				}
 				break;
 			case 'y':
 				if (yitcommand == NULL)
 					yitcommand = optarg;
 				else {
 					fprintf(stderr,
 _("%s: More than one -y option specified\n"),
 						progname);
 					return EXIT_FAILURE;
+				}
 				break;
 			case 'L':
 				if (leapsec == NULL)
 					leapsec = optarg;
 				else {
 					fprintf(stderr,
 _("%s: More than one -L option specified\n"),
 						progname);
 					return EXIT_FAILURE;
+				}
 				break;
 			case 'v':
 				noise = true;
 				break;
 			case 's':
 				warning(_("-s ignored"));
 				break;
+		}
 	if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
 		usage(stderr, EXIT_FAILURE);	/* usage message by request */
 	if (directory == NULL)
 		directory = TZDIR;
 	if (yitcommand == NULL)
 		yitcommand = "yearistype";
 	if (optind < argc && leapsec != NULL) {
 		infile(leapsec);
 		adjleap();
+	}
 	for (i = optind; i < argc; ++i)
 		infile(argv[i]);
 	if (errors)
 		return EXIT_FAILURE;
 	associate();
 	change_directory(directory);
 	for (i = 0; i < nzones; i = j) {
 		/*
 		** Find the next non-continuation zone entry.
 		*/
 		for (j = i + 1; j < nzones && zones[j].z_name == NULL; ++j)
 			continue;
 		outzone(&zones[i], j - i);
+	}
 	/*
 	** Make links.
 	*/
 	for (i = 0; i < nlinks; ++i) {
 		eat(links[i].l_filename, links[i].l_linenum);
 		dolink(links[i].l_from, links[i].l_to, false);
 		if (noise)
 			for (j = 0; j < nlinks; ++j)
 				if (strcmp(links[i].l_to,
 					links[j].l_from) == 0)
 						warning(_("link to link"));
+	}
 	if (lcltime != NULL) {
 		eat(_("command line"), 1);
 		dolink(lcltime, TZDEFAULT, true);
+	}
 	if (psxrules != NULL) {
 		eat(_("command line"), 1);
 		dolink(psxrules, TZDEFRULES, true);
+	}
 	if (warnings && (ferror(stderr) || fclose(stderr) != 0))
 	  return EXIT_FAILURE;
 	return errors ? EXIT_FAILURE : EXIT_SUCCESS;
+}
 static bool
 componentcheck(char const *name, char const *component,
 	       char const *component_end)
+{
 	enum { component_len_max = 14 };
 	size_t component_len = component_end - component;
 	if (component_len == 0) {
 	  if (!*name)
 	    error (_("empty file name"));
 	  else
 	    error (_(component == name
 		     ? "file name '%s' begins with '/'"
 		     : *component_end
 		     ? "file name '%s' contains '//'"
 		     : "file name '%s' ends with '/'"),
 		   name);
 	  return false;
+	}
 	if (0 < component_len && component_len <= 2
 	    && component[0] == '.' && component_end[-1] == '.') {
 	  error(_("file name '%s' contains '%.*s' component"),
 		name, (int) component_len, component);
 	  return false;
+	}
 	if (noise) {
 	  if (0 < component_len && component[0] == '-')
 	    warning(_("file name '%s' component contains leading '-'"),
 		    name);
 	  if (component_len_max < component_len)
 	    warning(_("file name '%s' contains overlength component"
 		      " '%.*s...'"),
 		    name, component_len_max, component);
+	}
 	return true;
+}
 static bool
 namecheck(const char *name)
+{
 	char const *cp;
 	/* Benign characters in a portable file name.  */
 	static char const benign[] =
 	  "-/_"
 	  "abcdefghijklmnopqrstuvwxyz"
 	  "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 	/* Non-control chars in the POSIX portable character set,
 	   excluding the benign characters.  */
 	static char const printable_and_not_benign[] =
 	  " !\"#$%&'()*+,.0123456789:;<=>?@[\\]^`{|}~";
 	char const *component = name;
 	for (cp = name; *cp; cp++) {
 		unsigned char c = *cp;
 		if (noise && !strchr(benign, c)) {
 			warning((strchr(printable_and_not_benign, c)
 				 ? _("file name '%s' contains byte '%c'")
 				 : _("file name '%s' contains byte '\\%o'")),
 				name, c);
+		}
 		if (c == '/') {
 			if (!componentcheck(name, component, cp))
 			  return false;
 			component = cp + 1;
+		}
+	}
 	return componentcheck(name, component, cp);
+}
 /* Create symlink contents suitable for symlinking FROM to TO, as a
    freshly allocated string.  FROM should be a relative file name, and
    is relative to the global variable DIRECTORY.  TO can be either
    relative or absolute.  */
 static char *
 relname(char const *from, char const *to)
+{
   size_t i, taillen, dotdotetcsize;
   size_t dir_len = 0, dotdots = 0, linksize = SIZE_MAX;
   char const *f = from;
   char *result = NULL;
   if (*to == '/') {
     /* Make F absolute too.  */
     size_t len = strlen(directory);
     bool needslash = len && directory[len - 1] != '/';
     linksize = len + needslash + strlen(from) + 1;
     f = result = emalloc(linksize);
     strcpy(result, directory);
     result[len] = '/';
     strcpy(result + len + needslash, from);
+  }
   for (i = 0; f[i] && f[i] == to[i]; i++)
     if (f[i] == '/')
       dir_len = i + 1;
   for (; f[i]; i++)
     dotdots += f[i] == '/' && f[i - 1] != '/';
   taillen = i - dir_len;
   dotdotetcsize = 3 * dotdots + taillen + 1;
   if (dotdotetcsize <= linksize) {
     if (!result)
       result = emalloc(dotdotetcsize);
     for (i = 0; i < dotdots; i++)
       memcpy(result + 3 * i, "../", 3);
     memmove(result + 3 * dotdots, f + dir_len, taillen + 1);
+  }
   return result;
+}
 static void
 dolink(char const *fromfield, char const *tofield, bool staysymlink)
+{
 	int fromisdir;
 	bool todirs_made = false;
 	int link_errno;
 	/*
 	** We get to be careful here since
 	** there's a fair chance of root running us.
 	*/
 	fromisdir = itsdir(fromfield);
 	if (fromisdir) {
 		char const *e = strerror(fromisdir < 0 ? errno : EPERM);
 		fprintf(stderr, _("%s: link from %s/%s failed: %s\n"),
 			progname, directory, fromfield, e);
 		exit(EXIT_FAILURE);
+	}
 	if (staysymlink)
 	  staysymlink = itsdir(tofield) == 2;
 	if (remove(tofield) == 0)
 	  todirs_made = true;
 	else if (errno != ENOENT) {
 	  char const *e = strerror(errno);
 	  fprintf(stderr, _("%s: Can't remove %s/%s: %s\n"),
 	    progname, directory, tofield, e);
 	  exit(EXIT_FAILURE);
+	}
 	link_errno = (staysymlink ? ENOTSUP
 		      : link(fromfield, tofield) == 0 ? 0 : errno);
 	if (link_errno == ENOENT && !todirs_made) {
 	  mkdirs(tofield, true);
 	  todirs_made = true;
 	  link_errno = link(fromfield, tofield) == 0 ? 0 : errno;
+	}
 	if (link_errno != 0) {
-	  const char *s = fromfield;
+	  bool absolute = *fromfield == '/';
-	  const char *t;
+	  char *linkalloc = absolute ? NULL : relname(fromfield, tofield);
-	  char *p;
+	  char const *contents = absolute ? fromfield : linkalloc;
-	  size_t dotdots = 0;
+	  int symlink_errno = symlink(contents, tofield) == 0 ? 0 : errno;
 	  char *symlinkcontents;
 	  int symlink_errno;
 	  do
 	    t = s;
 	  while ((s = strchr(s, '/'))
 		 && strncmp(fromfield, tofield, ++s - fromfield) == 0);
 	  for (s = tofield + (t - fromfield); *s; s++)
 	    dotdots += *s == '/';
 	  symlinkcontents = emalloc(3 * dotdots + strlen(t) + 1);
 	  for (p = symlinkcontents; dotdots-- != 0; p += 3)
 	    memcpy(p, "../", 3);
 	  strcpy(p, t);
 	  symlink_errno = symlink(symlinkcontents, tofield) == 0 ? 0 : errno;
 	  if (symlink_errno == ENOENT && !todirs_made) {
 	    mkdirs(tofield, true);
-	    symlink_errno = symlink(symlinkcontents, tofield) == 0 ? 0 : errno;
+	    symlink_errno = symlink(contents, tofield) == 0 ? 0 : errno;
+	  }
-	  free(symlinkcontents);
+	  free(linkalloc);
 	  if (symlink_errno == 0) {
 	    if (link_errno != ENOTSUP)
 	      warning(_("symbolic link used because hard link failed: %s"),
 		      strerror(link_errno));
 	  } else {
 	    FILE *fp, *tp;
 	    int c;
 	    fp = fopen(fromfield, "rb");
 	    if (!fp) {
 	      char const *e = strerror(errno);
 	      fprintf(stderr, _("%s: Can't read %s/%s: %s\n"),
 		      progname, directory, fromfield, e);
 	      exit(EXIT_FAILURE);
+	    }
 	    tp = fopen(tofield, "wb");
 	    if (!tp) {
 	      char const *e = strerror(errno);
 	      fprintf(stderr, _("%s: Can't create %s/%s: %s\n"),
 		      progname, directory, tofield, e);
 	      exit(EXIT_FAILURE);
+	    }
 	    while ((c = getc(fp)) != EOF)
 	      putc(c, tp);
 	    close_file(fp, directory, fromfield);
 	    close_file(tp, directory, tofield);
 	    if (link_errno != ENOTSUP)
 	      warning(_("copy used because hard link failed: %s"),
 		      strerror(link_errno));
 	    else if (symlink_errno != ENOTSUP)
 	      warning(_("copy used because symbolic link failed: %s"),
 		      strerror(symlink_errno));
+	  }
+	}
+}
 #define TIME_T_BITS_IN_FILE	64
 static zic_t const min_time = MINVAL (zic_t, TIME_T_BITS_IN_FILE);
 static zic_t const max_time = MAXVAL (zic_t, TIME_T_BITS_IN_FILE);
 /* Estimated time of the Big Bang, in seconds since the POSIX epoch.
    rounded downward to the negation of a power of two that is
    comfortably outside the error bounds.
    For the time of the Big Bang, see:
    Ade PAR, Aghanim N, Armitage-Caplan C et al.  Planck 2013 results.
    I. Overview of products and scientific results.
    arXiv:1303.5062 2013-03-20 20:10:01 UTC
    <http://arxiv.org/pdf/1303.5062v1> [PDF]
    Page 36, Table 9, row Age/Gyr, column Planck+WP+highL+BAO 68% limits
    gives the value 13.798 plus-or-minus 0.037 billion years.
    Multiplying this by 1000000000 and then by 31557600 (the number of
    seconds in an astronomical year) gives a value that is comfortably
    less than 2**59, so BIG_BANG is - 2**59.
    BIG_BANG is approximate, and may change in future versions.
    Please do not rely on its exact value.  */
 #ifndef BIG_BANG
 #define BIG_BANG (- (1LL << 59))
 #endif
 /* If true, work around GNOME bug 730332
    <https://bugzilla.gnome.org/show_bug.cgi?id=730332>
    by refusing to output time stamps before BIG_BANG.
    Such time stamps are physically suspect anyway.
    The GNOME bug is scheduled to be fixed in GNOME 3.22, and if so
    this workaround will no longer be needed when GNOME 3.21 and
    earlier are obsolete, say in the year 2021.  */
 enum { WORK_AROUND_GNOME_BUG_730332 = true };
 static const zic_t early_time = (WORK_AROUND_GNOME_BUG_730332
 				 ? BIG_BANG
 				 : MINVAL(zic_t, TIME_T_BITS_IN_FILE));
 /* Return 1 if NAME is a directory, 2 if a symbolic link, 0 if
    something else, -1 (setting errno) if trouble.  */
 static int
 itsdir(char const *name)
+{
 	struct stat st;
 	int res = lstat(name, &st);
 	if (res == 0) {
 #ifdef S_ISDIR
 		return S_ISDIR(st.st_mode) ? 1 : S_ISLNK(st.st_mode) ? 2 : 0;
 #else
 		size_t n = strlen(name);
 		char *nameslashdot = emalloc(n + 3);
 		bool dir;
 		memcpy(nameslashdot, name, n);
 		strcpy(&nameslashdot[n], &"/."[! (n && name[n - 1] != '/')]);
 		dir = lstat(nameslashdot, &st) == 0;
 		free(nameslashdot);
 		return dir;
 #endif
+	}
 	return -1;
+}
 /*
 ** Associate sets of rules with zones.
 */
 /*
 ** Sort by rule name.
 */
 static int
 rcomp(const void *cp1, const void *cp2)
+{
 	return strcmp(((const struct rule *) cp1)->r_name,
 		((const struct rule *) cp2)->r_name);
+}
 static void
 associate(void)
+{
 	struct zone *	zp;
 	struct rule *	rp;
 	int		base, out;
 	int		i, j;
 	if (nrules != 0) {
 		qsort(rules, (size_t)nrules, sizeof *rules, rcomp);
 		for (i = 0; i < nrules - 1; ++i) {
 			if (strcmp(rules[i].r_name,
 				rules[i + 1].r_name) != 0)
 					continue;
 			if (strcmp(rules[i].r_filename,
 				rules[i + 1].r_filename) == 0)
 					continue;
 			eat(rules[i].r_filename, rules[i].r_linenum);
 			warning(_("same rule name in multiple files"));
 			eat(rules[i + 1].r_filename, rules[i + 1].r_linenum);
 			warning(_("same rule name in multiple files"));
 			for (j = i + 2; j < nrules; ++j) {
 				if (strcmp(rules[i].r_name,
 					rules[j].r_name) != 0)
 						break;
 				if (strcmp(rules[i].r_filename,
 					rules[j].r_filename) == 0)
 						continue;
 				if (strcmp(rules[i + 1].r_filename,
 					rules[j].r_filename) == 0)
 						continue;
 				break;
+			}
 			i = j - 1;
+		}
+	}
 	for (i = 0; i < nzones; ++i) {
 		zp = &zones[i];
 		zp->z_rules = NULL;
 		zp->z_nrules = 0;
+	}
 	for (base = 0; base < nrules; base = out) {
 		rp = &rules[base];
 		for (out = base + 1; out < nrules; ++out)
 			if (strcmp(rp->r_name, rules[out].r_name) != 0)
 				break;
 		for (i = 0; i < nzones; ++i) {
 			zp = &zones[i];
 			if (strcmp(zp->z_rule, rp->r_name) != 0)
 				continue;
 			zp->z_rules = rp;
 			zp->z_nrules = out - base;
+		}
+	}
 	for (i = 0; i < nzones; ++i) {
 		zp = &zones[i];
 		if (zp->z_nrules == 0) {
 			/*
 			** Maybe we have a local standard time offset.
 			*/
 			eat(zp->z_filename, zp->z_linenum);
 			zp->z_stdoff = gethms(zp->z_rule, _("unruly zone"),
 				true);
 			/*
 			** Note, though, that if there's no rule,
 			** a '%s' in the format is a bad thing.
 			*/
 			if (zp->z_format_specifier == 's')
 				error("%s", _("%s in ruleless zone"));
+		}
+	}
 	if (errors)
 		exit(EXIT_FAILURE);
+}
 static void
 infile(const char *name)
+{
 	FILE *			fp;
 	char **		fields;
 	char *			cp;
 	const struct lookup *	lp;
 	int			nfields;
 	bool			wantcont;
 	int			num;
 	char				buf[BUFSIZ];
 	if (strcmp(name, "-") == 0) {
 		name = _("standard input");
 		fp = stdin;
 	} else if ((fp = fopen(name, "r")) == NULL) {
 		const char *e = strerror(errno);
 		fprintf(stderr, _("%s: Can't open %s: %s\n"),
 			progname, name, e);
 		exit(EXIT_FAILURE);
+	}
 	wantcont = false;
 	for (num = 1; ; ++num) {
 		eat(name, num);
 		if (fgets(buf, (int) sizeof buf, fp) != buf)
 			break;
 		cp = strchr(buf, '\n');
 		if (cp == NULL) {
 			error(_("line too long"));
 			exit(EXIT_FAILURE);
+		}
 		*cp = '\0';
 		fields = getfields(buf);
 		nfields = 0;
 		while (fields[nfields] != NULL) {
 			static char	nada;
 			if (strcmp(fields[nfields], "-") == 0)
 				fields[nfields] = &nada;
 			++nfields;
+		}
 		if (nfields == 0) {
 			/* nothing to do */
 		} else if (wantcont) {
 			wantcont = inzcont(fields, nfields);
 		} else {
 			lp = byword(fields[0], line_codes);
 			if (lp == NULL)
 				error(_("input line of unknown type"));
 			else switch ((int) (lp->l_value)) {
 				case LC_RULE:
 					inrule(fields, nfields);
 					wantcont = false;
 					break;
 				case LC_ZONE:
 					wantcont = inzone(fields, nfields);
 					break;
 				case LC_LINK:
 					inlink(fields, nfields);
 					wantcont = false;
 					break;
 				case LC_LEAP:
 					if (name != leapsec)
 					  warning(_("%s: Leap line in non leap"
 						    " seconds file %s"),
 						  progname, name);
 					else	inleap(fields, nfields);
 					wantcont = false;
 					break;
 				default:	/* "cannot happen" */
 					fprintf(stderr,
 _("%s: panic: Invalid l_value %d\n"),
 						progname, lp->l_value);
 					exit(EXIT_FAILURE);
+			}
+		}
 		free(fields);
+	}
 	close_file(fp, NULL, filename);
 	if (wantcont)
 		error(_("expected continuation line not found"));
+}
 /*
 ** Convert a string of one of the forms
 **	h	-h	hh:mm	-hh:mm	hh:mm:ss	-hh:mm:ss
 ** into a number of seconds.
 ** A null string maps to zero.
 ** Call error with errstring and return zero on errors.
 */
 static zic_t
 gethms(char const *string, char const *errstring, bool signable)
+{
 	zic_t	hh;
 	int	mm, ss, sign;
 	char	xs;
 	if (string == NULL || *string == '\0')
 		return 0;
 	if (!signable)
 		sign = 1;
 	else if (*string == '-') {
 		sign = -1;
 		++string;
 	} else	sign = 1;
 	if (sscanf(string, "%"SCNdZIC"%c", &hh, &xs) == 1)
 		mm = ss = 0;
 	else if (sscanf(string, "%"SCNdZIC":%d%c", &hh, &mm, &xs) == 2)
 		ss = 0;
 	else if (sscanf(string, "%"SCNdZIC":%d:%d%c", &hh, &mm, &ss, &xs)
 		 != 3) {
 			error("%s", errstring);
 			return 0;
+	}
 	if (hh < 0 ||
 		mm < 0 || mm >= MINSPERHOUR ||
 		ss < 0 || ss > SECSPERMIN) {
 			error("%s", errstring);
 			return 0;
+	}
 	if (ZIC_MAX / SECSPERHOUR < hh) {
 		error(_("time overflow"));
 		return 0;
+	}
 	if (noise && (hh > HOURSPERDAY ||
 		(hh == HOURSPERDAY && (mm != 0 || ss != 0))))
 warning(_("values over 24 hours not handled by pre-2007 versions of zic"));
 	return oadd(sign * hh * SECSPERHOUR,
 		    sign * (mm * SECSPERMIN + ss));
+}
 static void
 inrule(char **fields, int nfields)
+{
 	static struct rule	r;
 	if (nfields != RULE_FIELDS) {
 		error(_("wrong number of fields on Rule line"));
 		return;
+	}
 	if (*fields[RF_NAME] == '\0') {
 		error(_("nameless rule"));
 		return;
+	}
 	r.r_filename = filename;
 	r.r_linenum = linenum;
 	r.r_stdoff = gethms(fields[RF_STDOFF], _("invalid saved time"), true);
 	rulesub(&r, fields[RF_LOYEAR], fields[RF_HIYEAR], fields[RF_COMMAND],
 		fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
 	r.r_name = ecpyalloc(fields[RF_NAME]);
 	r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
 	if (max_abbrvar_len < strlen(r.r_abbrvar))
 		max_abbrvar_len = strlen(r.r_abbrvar);
 	rules = growalloc(rules, sizeof *rules, nrules, &nrules_alloc);
 	rules[nrules++] = r;
+}
 static bool
 inzone(char **fields, int nfields)
+{
 	int	i;
 	if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS) {
 		error(_("wrong number of fields on Zone line"));
 		return false;
+	}
 	if (strcmp(fields[ZF_NAME], TZDEFAULT) == 0 && lcltime != NULL) {
 		error(
 _("\"Zone %s\" line and -l option are mutually exclusive"),
 			TZDEFAULT);
 		return false;
+	}
 	if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL) {
 		error(
 _("\"Zone %s\" line and -p option are mutually exclusive"),
 			TZDEFRULES);
 		return false;
+	}
 	for (i = 0; i < nzones; ++i)
 		if (zones[i].z_name != NULL &&
 			strcmp(zones[i].z_name, fields[ZF_NAME]) == 0) {
 			error(
 _("duplicate zone name %s (file \"%s\", line %d)"),
 					fields[ZF_NAME],
 					zones[i].z_filename,
 					zones[i].z_linenum);
 				return false;
+		}
 	return inzsub(fields, nfields, false);
+}
 static bool
 inzcont(char **fields, int nfields)
+{
 	if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS) {
 		error(_("wrong number of fields on Zone continuation line"));
 		return false;
+	}
 	return inzsub(fields, nfields, true);
+}
 static bool
 inzsub(char **fields, int nfields, const int iscont)
+{
 	char *		cp;
 	char *		cp1;
 	static struct zone	z;
 	int		i_gmtoff, i_rule, i_format;
 	int		i_untilyear, i_untilmonth;
 	int		i_untilday, i_untiltime;
 	bool		hasuntil;
 	if (iscont) {
 		i_gmtoff = ZFC_GMTOFF;
 		i_rule = ZFC_RULE;
 		i_format = ZFC_FORMAT;
 		i_untilyear = ZFC_TILYEAR;
 		i_untilmonth = ZFC_TILMONTH;
 		i_untilday = ZFC_TILDAY;
 		i_untiltime = ZFC_TILTIME;
 		z.z_name = NULL;
 	} else if (!namecheck(fields[ZF_NAME]))
 		return false;
 	else {
 		i_gmtoff = ZF_GMTOFF;
 		i_rule = ZF_RULE;
 		i_format = ZF_FORMAT;
 		i_untilyear = ZF_TILYEAR;
 		i_untilmonth = ZF_TILMONTH;
 		i_untilday = ZF_TILDAY;
 		i_untiltime = ZF_TILTIME;
 		z.z_name = ecpyalloc(fields[ZF_NAME]);
+	}
 	z.z_filename = filename;
 	z.z_linenum = linenum;
 	z.z_gmtoff = gethms(fields[i_gmtoff], _("invalid UT offset"), true);
 	if ((cp = strchr(fields[i_format], '%')) != 0) {
 		if ((*++cp != 's' && *cp != 'z') || strchr(cp, '%')
 		    || strchr(fields[i_format], '/')) {
 			error(_("invalid abbreviation format"));
 			return false;
+		}
+	}
 	z.z_rule = ecpyalloc(fields[i_rule]);
 	z.z_format = cp1 = ecpyalloc(fields[i_format]);
 	z.z_format_specifier = cp ? *cp : '\0';
 	if (z.z_format_specifier == 'z') {
 	  if (noise)
 	    warning(_("format '%s' not handled by pre-2015 versions of zic"),
 		    z.z_format);
 	  cp1[cp - fields[i_format]] = 's';
+	}
 	if (max_format_len < strlen(z.z_format))
 		max_format_len = strlen(z.z_format);
 	hasuntil = nfields > i_untilyear;
 	if (hasuntil) {
 		z.z_untilrule.r_filename = filename;
 		z.z_untilrule.r_linenum = linenum;
 		rulesub(&z.z_untilrule,
 			fields[i_untilyear],
 			"only",
 			"",
 			(nfields > i_untilmonth) ?
 			fields[i_untilmonth] : "Jan",
 			(nfields > i_untilday) ? fields[i_untilday] : "1",
 			(nfields > i_untiltime) ? fields[i_untiltime] : "0");
 		z.z_untiltime = rpytime(&z.z_untilrule,
 			z.z_untilrule.r_loyear);
 		if (iscont && nzones > 0 &&
 			z.z_untiltime > min_time &&
 			z.z_untiltime < max_time &&
 			zones[nzones - 1].z_untiltime > min_time &&
 			zones[nzones - 1].z_untiltime < max_time &&
 			zones[nzones - 1].z_untiltime >= z.z_untiltime) {
 				error(_(
 "Zone continuation line end time is not after end time of previous line"
 					));
 				return false;
+		}
+	}
 	zones = growalloc(zones, sizeof *zones, nzones, &nzones_alloc);
 	zones[nzones++] = z;
 	/*
 	** If there was an UNTIL field on this line,
 	** there's more information about the zone on the next line.
 	*/
 	return hasuntil;
+}
 static void
 inleap(char **fields, int nfields)
+{
 	const char *		cp;
 	const struct lookup *	lp;
 	int			i, j;
 	zic_t			year;
 	int			month, day;
 	zic_t			dayoff, tod;
 	zic_t			t;
 	char			xs;
 	if (nfields != LEAP_FIELDS) {
 		error(_("wrong number of fields on Leap line"));
 		return;
+	}
 	dayoff = 0;
 	cp = fields[LP_YEAR];
 	if (sscanf(cp, "%"SCNdZIC"%c", &year, &xs) != 1) {
 		/*
 		** Leapin' Lizards!
 		*/
 		error(_("invalid leaping year"));
 		return;
+	}
 	if (!leapseen || leapmaxyear < year)
 		leapmaxyear = year;
 	if (!leapseen || leapminyear > year)
 		leapminyear = year;
 	leapseen = true;
 	j = EPOCH_YEAR;
 	while (j != year) {
 		if (year > j) {
 			i = len_years[isleap(j)];
 			++j;
 		} else {
 			--j;
 			i = -len_years[isleap(j)];
+		}
 		dayoff = oadd(dayoff, i);
+	}
 	if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL) {
 		error(_("invalid month name"));
 		return;
+	}
 	month = lp->l_value;
 	j = TM_JANUARY;
 	while (j != month) {
 		i = len_months[isleap(year)][j];
 		dayoff = oadd(dayoff, i);
 		++j;
+	}
 	cp = fields[LP_DAY];
 	if (sscanf(cp, "%d%c", &day, &xs) != 1 ||
 		day <= 0 || day > len_months[isleap(year)][month]) {
 			error(_("invalid day of month"));
 			return;
+	}
 	dayoff = oadd(dayoff, day - 1);
 	if (dayoff < min_time / SECSPERDAY) {
 		error(_("time too small"));
 		return;
+	}
 	if (dayoff > max_time / SECSPERDAY) {
 		error(_("time too large"));
 		return;
+	}
 	t = dayoff * SECSPERDAY;
 	tod = gethms(fields[LP_TIME], _("invalid time of day"), false);
 	cp = fields[LP_CORR];
+	{
 		bool	positive;
 		int	count;
 		if (strcmp(cp, "") == 0) { /* infile() turns "-" into "" */
 			positive = false;
 			count = 1;
 		} else if (strcmp(cp, "--") == 0) {
 			positive = false;
 			count = 2;
 		} else if (strcmp(cp, "+") == 0) {
 			positive = true;
 			count = 1;
 		} else if (strcmp(cp, "++") == 0) {
 			positive = true;
 			count = 2;
 		} else {
 			error(_("illegal CORRECTION field on Leap line"));
 			return;
+		}
 		if ((lp = byword(fields[LP_ROLL], leap_types)) == NULL) {
 			error(_(
 				"illegal Rolling/Stationary field on Leap line"
 				));
 			return;
+		}
 		t = tadd(t, tod);
 		if (t < early_time) {
 			error(_("leap second precedes Big Bang"));
 			return;
+		}
 		leapadd(t, positive, lp->l_value, count);
+	}
+}
 static void
 inlink(char **fields, int nfields)
+{
 	struct link	l;
 	if (nfields != LINK_FIELDS) {
 		error(_("wrong number of fields on Link line"));
 		return;
+	}
 	if (*fields[LF_FROM] == '\0') {
 		error(_("blank FROM field on Link line"));
 		return;
+	}
 	if (! namecheck(fields[LF_TO]))
 	  return;
 	l.l_filename = filename;
 	l.l_linenum = linenum;
 	l.l_from = ecpyalloc(fields[LF_FROM]);
 	l.l_to = ecpyalloc(fields[LF_TO]);
 	links = growalloc(links, sizeof *links, nlinks, &nlinks_alloc);
 	links[nlinks++] = l;
+}
 static void
 rulesub(struct rule *rp, const char *loyearp, const char *hiyearp,
     const char *typep, const char *monthp, const char *dayp,
     const char *timep)
+{
 	const struct lookup *	lp;
 	const char *		cp;
 	char *			dp;
 	char *			ep;
 	char			xs;
 	if ((lp = byword(monthp, mon_names)) == NULL) {
 		error(_("invalid month name"));
 		return;
+	}
 	rp->r_month = lp->l_value;
 	rp->r_todisstd = false;
 	rp->r_todisgmt = false;
 	dp = ecpyalloc(timep);
 	if (*dp != '\0') {
 		ep = dp + strlen(dp) - 1;
 		switch (lowerit(*ep)) {
 			case 's':	/* Standard */
 				rp->r_todisstd = true;
 				rp->r_todisgmt = false;
 				*ep = '\0';
 				break;
 			case 'w':	/* Wall */
 				rp->r_todisstd = false;
 				rp->r_todisgmt = false;
 				*ep = '\0';
 				break;
 			case 'g':	/* Greenwich */
 			case 'u':	/* Universal */
 			case 'z':	/* Zulu */
 				rp->r_todisstd = true;
 				rp->r_todisgmt = true;
 				*ep = '\0';
 				break;
+		}
+	}
 	rp->r_tod = gethms(dp, _("invalid time of day"), false);
 	free(dp);
 	/*
 	** Year work.
 	*/
 	cp = loyearp;
 	lp = byword(cp, begin_years);
 	rp->r_lowasnum = lp == NULL;
 	if (!rp->r_lowasnum) switch ((int) lp->l_value) {
 		case YR_MINIMUM:
 			rp->r_loyear = ZIC_MIN;
 			break;
 		case YR_MAXIMUM:
 			rp->r_loyear = ZIC_MAX;
 			break;
 		default:	/* "cannot happen" */
 			fprintf(stderr,
 				_("%s: panic: Invalid l_value %d\n"),
 				progname, lp->l_value);
 			exit(EXIT_FAILURE);
 	} else if (sscanf(cp, "%"SCNdZIC"%c", &rp->r_loyear, &xs) != 1) {
 		error(_("invalid starting year"));
 		return;
+	}
 	cp = hiyearp;
 	lp = byword(cp, end_years);
 	rp->r_hiwasnum = lp == NULL;
 	if (!rp->r_hiwasnum) switch ((int) lp->l_value) {
 		case YR_MINIMUM:
 			rp->r_hiyear = ZIC_MIN;
 			break;
 		case YR_MAXIMUM:
 			rp->r_hiyear = ZIC_MAX;
 			break;
 		case YR_ONLY:
 			rp->r_hiyear = rp->r_loyear;
 			break;
 		default:	/* "cannot happen" */
 			fprintf(stderr,
 				_("%s: panic: Invalid l_value %d\n"),
 				progname, lp->l_value);
 			exit(EXIT_FAILURE);
 	} else if (sscanf(cp, "%"SCNdZIC"%c", &rp->r_hiyear, &xs) != 1) {
 		error(_("invalid ending year"));
 		return;
+	}
 	if (rp->r_loyear > rp->r_hiyear) {
 		error(_("starting year greater than ending year"));
 		return;
+	}
 	if (*typep == '\0')
 		rp->r_yrtype = NULL;
 	else {
 		if (rp->r_loyear == rp->r_hiyear) {
 			error(_("typed single year"));
 			return;
+		}
 		rp->r_yrtype = ecpyalloc(typep);
+	}
 	/*
 	** Day work.
 	** Accept things such as:
 	**	1
 	**	last-Sunday
 	**	Sun<=20
 	**	Sun>=7
 	*/
 	dp = ecpyalloc(dayp);
 	if ((lp = byword(dp, lasts)) != NULL) {
 		rp->r_dycode = DC_DOWLEQ;
 		rp->r_wday = lp->l_value;
 		rp->r_dayofmonth = len_months[1][rp->r_month];
 	} else {
 		if ((ep = strchr(dp, '<')) != 0)
 			rp->r_dycode = DC_DOWLEQ;
 		else if ((ep = strchr(dp, '>')) != 0)
 			rp->r_dycode = DC_DOWGEQ;
 		else {
 			ep = dp;
 			rp->r_dycode = DC_DOM;
+		}
 		if (rp->r_dycode != DC_DOM) {
 			*ep++ = 0;
 			if (*ep++ != '=') {
 				error(_("invalid day of month"));
 				free(dp);
 				return;
+			}
 			if ((lp = byword(dp, wday_names)) == NULL) {
 				error(_("invalid weekday name"));
 				free(dp);
 				return;
+			}
 			rp->r_wday = lp->l_value;
+		}
 		if (sscanf(ep, "%d%c", &rp->r_dayofmonth, &xs) != 1 ||
 			rp->r_dayofmonth <= 0 ||
 			(rp->r_dayofmonth > len_months[1][rp->r_month])) {
 				error(_("invalid day of month"));
 				free(dp);
 				return;
+		}
+	}
 	free(dp);
+}
 static void
 convert(const zic_t val, char *const buf)
+{
 	int	i;
 	int	shift;
 	unsigned char *const b = (unsigned char *) buf;
 	for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
 		b[i] = val >> shift;
+}
 static void
 convert64(const zic_t val, char *const buf)
+{
 	int	i;
 	int	shift;
 	unsigned char *const b = (unsigned char *) buf;
 	for (i = 0, shift = 56; i < 8; ++i, shift -= 8)
 		b[i] = val >> shift;
+}
 static void
 puttzcode(const zic_t val, FILE *const fp)
+{
 	char	buf[4];
 	convert(val, buf);
 	fwrite(buf, sizeof buf, (size_t) 1, fp);
+}
 static void
 puttzcode64(const zic_t val, FILE *const fp)
+{
 	char	buf[8];
 	convert64(val, buf);
 	fwrite(buf, sizeof buf, (size_t) 1, fp);
+}
 static int
 atcomp(const void *avp, const void *bvp)
+{
 	const zic_t	a = ((const struct attype *) avp)->at;
 	const zic_t	b = ((const struct attype *) bvp)->at;
 	return (a < b) ? -1 : (a > b);
+}
 static bool
 is32(const zic_t x)
+{
 	return INT32_MIN <= x && x <= INT32_MAX;
+}
 static void
 writezone(const char *const name, const char *const string, char version)
+{
 	FILE *			fp;
 	int			i, j;
 	int			leapcnt32, leapi32;
 	int			timecnt32, timei32;
 	int			pass;
 	static const struct tzhead	tzh0;
 	static struct tzhead		tzh;
 	bool dir_checked = false;
 	zic_t one = 1;
 	zic_t y2038_boundary = one << 31;
 	int nats = timecnt + WORK_AROUND_QTBUG_53071;
 	zic_t *ats = zic_malloc(size_product(nats, sizeof *ats + 1));
 	void *typesptr = ats + nats;
 	unsigned char *types = typesptr;
 	/*
 	** Sort.
 	*/
 	if (timecnt > 1)
 		qsort(attypes, (size_t) timecnt, sizeof *attypes, atcomp);
 	/*
 	** Optimize.
 	*/
+	{
 		int	fromi;
 		int	toi;
 		toi = 0;
 		fromi = 0;
 		while (fromi < timecnt && attypes[fromi].at < early_time)
 			++fromi;
 		for ( ; fromi < timecnt; ++fromi) {
 			if (toi > 1 && ((attypes[fromi].at +
 				gmtoffs[attypes[toi - 1].type]) <=
 				(attypes[toi - 1].at +
 				gmtoffs[attypes[toi - 2].type]))) {
 					attypes[toi - 1].type =
 						attypes[fromi].type;
 					continue;
+			}
 			if (toi == 0
 			    || attypes[fromi].dontmerge
 			    || attypes[toi - 1].type != attypes[fromi].type)
 					attypes[toi++] = attypes[fromi];
+		}
 		timecnt = toi;
+	}
 	if (noise && timecnt > 1200)
 		warning(_("pre-2014 clients may mishandle"
 			  " more than 1200 transition times"));
 	/*
 	** Transfer.
 	*/
 	for (i = 0; i < timecnt; ++i) {
 		ats[i] = attypes[i].at;
 		types[i] = attypes[i].type;
+	}
 	/* Work around QTBUG-53071 for time stamps less than y2038_boundary - 1,
 	   by inserting a no-op transition at time y2038_boundary - 1.
 	   This works only for timestamps before the boundary, which
 	   should be good enough in practice as QTBUG-53071 should be
 	   long-dead by 2038.  */
 	if (WORK_AROUND_QTBUG_53071 && timecnt != 0
 	    && ats[timecnt - 1] < y2038_boundary - 1 && strchr(string, '<')) {
 	  ats[timecnt] = y2038_boundary - 1;
 	  types[timecnt] = types[timecnt - 1];
 	  timecnt++;
+	}
 	/*
 	** Correct for leap seconds.
 	*/
 	for (i = 0; i < timecnt; ++i) {
 		j = leapcnt;
 		while (--j >= 0)
 			if (ats[i] > trans[j] - corr[j]) {
 				ats[i] = tadd(ats[i], corr[j]);
 				break;
+			}
+	}
 	/*
 	** Figure out 32-bit-limited starts and counts.
 	*/
 	timecnt32 = timecnt;
 	timei32 = 0;
 	leapcnt32 = leapcnt;
 	leapi32 = 0;
 	while (timecnt32 > 0 && !is32(ats[timecnt32 - 1]))
 		--timecnt32;
 	while (timecnt32 > 0 && !is32(ats[timei32])) {
 		--timecnt32;
 		++timei32;
+	}
 	/*
 	** Output an INT32_MIN "transition" if appropriate; see below.
 	*/
 	if (timei32 > 0 && ats[timei32] > INT32_MIN) {
 		--timei32;
 		++timecnt32;
+	}
 	while (leapcnt32 > 0 && !is32(trans[leapcnt32 - 1]))
 		--leapcnt32;
 	while (leapcnt32 > 0 && !is32(trans[leapi32])) {
 		--leapcnt32;
 		++leapi32;
+	}
 	/*
 	** Remove old file, if any, to snap links.
 	*/
 	if (remove(name) == 0)
 		dir_checked = true;
 	else if (errno != ENOENT) {
 		const char *e = strerror(errno);
 		fprintf(stderr, _("%s: Can't remove %s/%s: %s\n"),
 			progname, directory, name, e);
 		exit(EXIT_FAILURE);
+	}
 	fp = fopen(name, "wb");
 	if (!fp) {
 	  int fopen_errno = errno;
 	  if (fopen_errno == ENOENT && !dir_checked) {
 	    mkdirs(name, true);
 	    fp = fopen(name, "wb");
 	    fopen_errno = errno;
+	  }
 	  if (!fp) {
 	    fprintf(stderr, _("%s: Can't create %s/%s: %s\n"),
 		    progname, directory, name, strerror(fopen_errno));
 	    exit(EXIT_FAILURE);
+	  }
+	}
 	for (pass = 1; pass <= 2; ++pass) {
 		int	thistimei, thistimecnt;
 		int	thisleapi, thisleapcnt;
 		int	thistimelim, thisleaplim;
 		int		writetype[TZ_MAX_TYPES];
 		int		typemap[TZ_MAX_TYPES];
 		int	thistypecnt;
 		char		thischars[TZ_MAX_CHARS];
 		char		thischarcnt;
 		int		indmap[TZ_MAX_CHARS];
 		if (pass == 1) {
 			thistimei = timei32;
 			thistimecnt = timecnt32;
 			thisleapi = leapi32;
 			thisleapcnt = leapcnt32;
 		} else {
 			thistimei = 0;
 			thistimecnt = timecnt;
 			thisleapi = 0;
 			thisleapcnt = leapcnt;
+		}
 		thistimelim = thistimei + thistimecnt;
 		thisleaplim = thisleapi + thisleapcnt;
 		for (i = 0; i < typecnt; ++i)
 			writetype[i] = thistimecnt == timecnt;
 		if (thistimecnt == 0) {
 			/*
 			** No transition times fall in the current
 			** (32- or 64-bit) window.
 			*/
 			if (typecnt != 0)
 				writetype[typecnt - 1] = true;
 		} else {
 			for (i = thistimei - 1; i < thistimelim; ++i)
 				if (i >= 0)
 					writetype[types[i]] = true;
 			/*
 			** For America/Godthab and Antarctica/Palmer
 			*/
 			if (thistimei == 0)
 				writetype[0] = true;
+		}
 #ifndef LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH
 		/*
 		** For some pre-2011 systems: if the last-to-be-written
 		** standard (or daylight) type has an offset different from the
 		** most recently used offset,
 		** append an (unused) copy of the most recently used type
 		** (to help get global "altzone" and "timezone" variables