Fri Sep 20 19:06:54 2013 UTC ()

Welcome to tzcode 2013e:

  Changes affecting API

    The 'zic' command now outputs a dummy transition when far-future
    data can't be summarized using a TZ string, and uses a 402-year
    window rather than a 400-year window.  For the current data, this
    affects only the Asia/Tehran file.  It does not affect any of the
    time stamps that this file represents, so zdump outputs the same
    information as before.  (Thanks to Andrew Main (Zefram).)

    The 'date' command has a new '-r' option, which lets you specify
    the integer time to display, a la FreeBSD.

    The 'tzselect' command has two new options '-c' and '-n', which lets you
    select a zone based on latitude and longitude.

    The 'zic' command's '-v' option now warns about constructs that
    require the new version-3 binary file format.  (Thanks to Arthur
    David Olson for the suggestion.)

    Support for floating-point time_t has been removed.
    It was always dicey, and POSIX no longer requires it.
    (Thanks to Eric Blake for suggesting to the POSIX committee to
    remove it, and thanks to Alan Barrett, Clive D.W. Feather, Andy
    Heninger, Arthur David Olson, and Alois Treindl, for reporting
    bugs and elucidating some of the corners of the old floating-point
    implementation.)

    The signatures of 'offtime', 'timeoff', and 'gtime' have been
    changed back to the old practice of using 'long' to represent UT
    offsets.  This had been inadvertently and mistakenly changed to
    'int_fast32_t'.  (Thanks to Christos Zoulos.)

    The code avoids undefined behavior on integer overflow in some
    more places, including gmtime, localtime, mktime and zdump.

  Changes affecting the zdump utility

    zdump now outputs "UT" when referring to Universal Time, not "UTC".
    "UTC" does not make sense for time stamps that predate the introduction
    of UTC, whereas "UT", a more-generic term, does.  (Thanks to Steve Allen
    for clarifying UT vs UTC.)

  Data changes affecting behavior of tzselect and similar programs

    Country code BQ is now called the more-common name "Caribbean Netherlands"
    rather than the more-official "Bonaire, St Eustatius & Saba".

    Remove from zone.tab the names America/Montreal, America/Shiprock,
    and Antarctica/South_Pole, as they are equivalent to existing
    same-country-code zones for post-1970 time stamps.  The data for
    these names are unchanged, so the names continue to work as before.

  Changes affecting code internals

    zic -c now runs way faster on 64-bit hosts when given large numbers.

    zic now uses vfprintf to avoid allocating and freeing some memory.

    tzselect now computes the list of continents from the data,
    rather than have it hard-coded.

    Minor changes pacify GCC 4.7.3 and GCC 4.8.1.

  Changes affecting the build procedure

    The 'leapseconds' file is now generated automatically from a
    new file 'leap-seconds.list', which is a copy of
    <ftp://time.nist.gov/pub/leap-seconds.list>.
    A new source file 'leapseconds.awk' implements this.
    The goal is simplification of the future maintenance of 'leapseconds'.

    When building the 'posix' or 'right' subdirectories, if the
    subdirectory would be a copy of the default subdirectory, it is
    now made a symbolic link if that is supported.  This saves about
    2 MB of file system space.

    The links America/Shiprock and Antarctica/South_Pole have been
    moved to the 'backward' file.  This affects only nondefault builds
    that omit 'backward'.

  Changes affecting documentation and commentary

    Changes to the 'tzfile' man page

      It now mentions that the binary file format may be extended in
      future versions by appending data.

      It now refers to the 'zdump' and 'zic' man pages.

    Changes to the 'zic' man page

      It lists conditions that elicit a warning with '-v'.

      It says that the behavior is unspecified when duplicate names
      are given, or if the source of one link is the target of another.

      Its examples are updated to match the latest data.

      The definition of white space has been clarified slightly.
      (Thanks to Michael Deckers.)

    Changes to the 'Theory' file

      There is a new section about the accuracy of the tz database,
      describing the many ways that errors can creep in, and
      explaining why so many of the pre-1970 time stamps are wrong or
      misleading (thanks to Steve Allen, Lester Caine, and Garrett
      Wollman for discussions that contributed to this).

      The 'Theory' file describes LMT better (this follows a
      suggestion by Guy Harris).

      It refers to the 2013 edition of POSIX rather than the 2004 edition.

      It's mentioned that excluding 'backward' should not affect the
      other data, and it suggests at least one zone.tab name per
      inhabited country (thanks to Stephen Colebourne).

      Some longstanding restrictions on names are documented, e.g.,
      'America/New_York' precludes 'America/New_York/Bronx'.

      It gives more reasons for the 1970 cutoff.

      It now mentions which time_t variants are supported, such as
      signed integer time_t.  (Thanks to Paul Goyette for reporting
      typos in an experimental version of this change.)

      (Thanks to Philip Newton for correcting typos in these changes.)

    Documentation and commentary is more careful to distinguish UT in
    general from UTC in particular.  (Thanks to Steve Allen.)

    Add a better source for the Zurich 1894 transition.
    (Thanks to Pierre-Yves Berger.)

    Update shapefile citations in tz-link.htm.  (Thanks to Guy Harris.)


(christos)

diff -r1.14 -r1.15 src/lib/libc/time/Makefile
diff -r1.14 -r1.15 src/lib/libc/time/difftime.c
diff -r1.13 -r1.14 src/lib/libc/time/Theory
diff -r1.5 -r1.6 src/lib/libc/time/checktab.awk
diff -r1.47 -r1.48 src/lib/libc/time/ctime.3
diff -r1.77 -r1.78 src/lib/libc/time/localtime.c
diff -r1.29 -r1.30 src/lib/libc/time/private.h
diff -r1.29 -r1.30 src/lib/libc/time/strftime.3
diff -r1.28 -r1.29 src/lib/libc/time/strftime.c
diff -r1.11 -r1.12 src/lib/libc/time/tz-link.htm
diff -r1.11 -r1.12 src/lib/libc/time/tzfile.h
diff -r1.19 -r1.20 src/lib/libc/time/tzfile.5
diff -r1.4 -r1.5 src/lib/libc/time/tzselect.8
diff -r1.8 -r1.9 src/lib/libc/time/tzselect.ksh
diff -r1.25 -r1.26 src/lib/libc/time/tzset.3
diff -r1.1 -r1.2 src/lib/libc/time/version.h
diff -r1.10 -r1.11 src/lib/libc/time/zdump.8
diff -r1.30 -r1.31 src/lib/libc/time/zdump.c
diff -r1.20 -r1.21 src/lib/libc/time/zic.8
diff -r1.42 -r1.43 src/lib/libc/time/zic.c

--- src/lib/libc/time/Makefile 2013/07/17 20:13:04	1.14
+++ src/lib/libc/time/Makefile 2013/09/20 19:06:54	1.15

 @@ -1,67 +1,68 @@
 # <pre>
 # This file is in the public domain, so clarified as of
 # 2009-05-17 by Arthur David Olson.
 # Package name for the code distribution.
 PACKAGE=	tzcode
 # Version numbers of the code and data distributions.
-VERSION=	2013d
+VERSION=	2013e
 # Email address for bug reports.
 BUGEMAIL=	tz@iana.org
 # Change the line below for your time zone (after finding the zone you want in
 # the time zone files, or adding it to a time zone file).
 # Alternately, if you discover you've got the wrong time zone, you can just
 #	zic -l rightzone
 # to correct things.
 # Use the command
 #	make zonenames
 # to get a list of the values you can use for LOCALTIME.
 LOCALTIME=	GMT
 # If you want something other than Eastern United States time as a template
 # for handling POSIX-style time zone environment variables,
 # change the line below (after finding the zone you want in the
 # time zone files, or adding it to a time zone file).
 # (When a POSIX-style environment variable is handled, the rules in the
 # template file are used to determine "spring forward" and "fall back" days and
-# times; the environment variable itself specifies UTC offsets of standard and
+# times; the environment variable itself specifies UT offsets of standard and
 # summer time.)
 # Alternately, if you discover you've got the wrong time zone, you can just
 #	zic -p rightzone
 # to correct things.
 # Use the command
 #	make zonenames
 # to get a list of the values you can use for POSIXRULES.
 # If you want POSIX compatibility, use "America/New_York".
 POSIXRULES=	America/New_York
 # Also see TZDEFRULESTRING below, which takes effect only
 # if the time zone files cannot be accessed.
 # Everything gets put in subdirectories of. . .
 TOPDIR=		/usr/local
 # "Compiled" time zone information is placed in the "TZDIR" directory
 # (and subdirectories).
 # Use an absolute path name for TZDIR unless you're just testing the software.
-TZDIR=		$(TOPDIR)/etc/zoneinfo
+TZDIR_BASENAME=	zoneinfo
 TZDIR=		$(TOPDIR)/etc/$(TZDIR_BASENAME)
 # Types to try, as an alternative to time_t.  int64_t should be first.
 TIME_T_ALTERNATIVES= int64_t int32_t uint32_t uint64_t
 # The "tzselect", "zic", and "zdump" commands get installed in. . .
 ETCDIR=		$(TOPDIR)/etc
 # If you "make INSTALL", the "date" command gets installed in. . .
 BINDIR=		$(TOPDIR)/bin
 # Manual pages go in subdirectories of. . .
 @@ -110,27 +111,26 @@ LDLIBS=
 #  -DHAVE_SETTIMEOFDAY=1 if settimeofday has just 1 arg (SVR4)
 #  -DHAVE_SETTIMEOFDAY=2 if settimeofday uses 2nd arg (4.3BSD)
 #  -DHAVE_SETTIMEOFDAY=3 if settimeofday ignores 2nd arg (4.4BSD)
 #  -DHAVE_STDINT_H=1 if you have a pre-C99 compiler with "stdint.h"
 #  -DHAVE_SYMLINK=0 if your system lacks the symlink function
 #  -DHAVE_SYS_STAT_H=0 if your compiler lacks a "sys/stat.h"
 #  -DHAVE_SYS_WAIT_H=0 if your compiler lacks a "sys/wait.h"
 #  -DHAVE_UNISTD_H=0 if your compiler lacks a "unistd.h" (Microsoft C++ 7?)
 #  -DHAVE_UTMPX_H=1 if your compiler has a "utmpx.h"
 #  -DLOCALE_HOME=\"path\" if locales are in "path", not "/usr/lib/locale"
 #  -DNO_RUN_TIME_WARNINGS_ABOUT_YEAR_2000_PROBLEMS_THANK_YOU=1
 #	if you do not want run time warnings about formats that may cause
 #	year 2000 grief
 #  -DTIME_T_FLOATING=1 if your time_t (or time_tz) is floating point
 #  -Dtime_tz=\"T\" to use T as the time_t type, rather than the system time_t
 #  -DTZ_DOMAIN=\"foo\" to use "foo" for gettext domain name; default is "tz"
 #  -TTZ_DOMAINDIR=\"/path\" to use "/path" for gettext directory;
 #	the default is system-supplied, typically "/usr/lib/locale"
 #  -DTZDEFRULESTRING=\",date/time,date/time\" to default to the specified
 #  -DNO_ERROR_IN_DST_GAP=1
 #	if you want mktime() not to return an error in the DST gap.
 #  -DZIC_MAX_ABBR_LEN_WO_WARN=3
 #	(or some other number) to set the maximum time zone abbreviation length
 #	that zic will accept without a warning (the default is 6)
 #  $(GCC_DEBUG_FLAGS) if you are using GCC and want lots of checking
 GCC_DEBUG_FLAGS = -Dlint -g3 -O3 -fno-common -fstrict-aliasing \
 	-Wall -Wextra \
 @@ -178,27 +178,27 @@ GCC_DEBUG_FLAGS = -Dlint -g3 -O3 -fno-co
 # If you want functions that were inspired by early versions of X3J11's work,
 # add
 #	-DSTD_INSPIRED
 # to the end of the "CFLAGS=" line.  This arranges for the functions
 # "tzsetwall", "offtime", "timelocal", "timegm", "timeoff",
 # "posix2time", and "time2posix" to be added to the time conversion library.
 # "tzsetwall" is like "tzset" except that it arranges for local wall clock
 # time (rather than the time specified in the TZ environment variable)
 # to be used.
 # "offtime" is like "gmtime" except that it accepts a second (long) argument
 # that gives an offset to add to the time_t when converting it.
 # "timelocal" is equivalent to "mktime".
 # "timegm" is like "timelocal" except that it turns a struct tm into
-# a time_t using UTC (rather than local time as "timelocal" does).
+# a time_t using UT (rather than local time as "timelocal" does).
 # "timeoff" is like "timegm" except that it accepts a second (long) argument
 # that gives an offset to use when converting to a time_t.
 # "posix2time" and "time2posix" are described in an included manual page.
 # X3J11's work does not describe any of these functions.
 # Sun has provided "tzsetwall", "timelocal", and "timegm" in SunOS 4.0.
 # These functions may well disappear in future releases of the time
 # conversion package.
+#
 # If you'll never want to handle solar-time-based time zones, add
 #	-DNOSOLAR
 # to the end of the "CFLAGS=" line
 # (and comment out the "SDATA=" line below).
 # This reduces (slightly) the run-time data-space requirements of
 @@ -232,26 +232,28 @@ GCC_DEBUG_FLAGS = -Dlint -g3 -O3 -fno-co
 # before the first Monday in January when a "%V" format is used and January 1
 # falls on a Friday, Saturday, or Sunday.
 CFLAGS=
 # Linker flags.  Default to $(LFLAGS) for backwards compatibility
 # to tzcode2012h and earlier.
 LDFLAGS=	$(LFLAGS)
 zic=		./zic
 ZIC=		$(zic) $(ZFLAGS)
 ZFLAGS=
 # The name of a Posix-compliant `awk' on your system.
 AWK=		awk
 # The full path name of a Posix-compliant shell that supports the Korn shell's
 # 'select' statement, as an extension.  These days, Bash is the most popular.
 KSHELL=		/bin/bash
 # The path where SGML DTDs are kept.
 # The default is appropriate for Ubuntu 12.10.
 SGML_TOPDIR= /usr
 SGML_DTDDIR= $(SGML_TOPDIR)/share/xml/w3c-sgml-lib/schema/dtd
 SGML_SEARCH_PATH= $(SGML_DTDDIR)/REC-html401-19991224
 @@ -309,111 +311,128 @@ NONLIBSRCS=	zic.c zdump.c scheck.c iallo
 NEWUCBSRCS=	date.c strftime.c
 SOURCES=	$(HEADERS) $(LIBSRCS) $(NONLIBSRCS) $(NEWUCBSRCS) tzselect.ksh
 MANS=		newctime.3 newstrftime.3 newtzset.3 time2posix.3 \
 			tzfile.5 tzselect.8 zic.8 zdump.8
 COMMON=		Makefile
 DOCS=		README Theory $(MANS) date.1
 PRIMARY_YDATA=	africa antarctica asia australasia \
 		europe northamerica southamerica
 YDATA=		$(PRIMARY_YDATA) pacificnew etcetera backward
 NDATA=		systemv factory
 SDATA=		solar87 solar88 solar89
 TDATA=		$(YDATA) $(NDATA) $(SDATA)
 TABDATA=	iso3166.tab zone.tab
-DATA=		$(YDATA) $(NDATA) $(SDATA) $(TABDATA) leapseconds yearistype.sh
+DATA=		$(YDATA) $(NDATA) $(SDATA) $(TABDATA) \
 			leap-seconds.list yearistype.sh
 WEB_PAGES=	tz-art.htm tz-link.htm
 AWK_SCRIPTS=	checktab.awk leapseconds.awk
 MISC=		usno1988 usno1989 usno1989a usno1995 usno1997 usno1998 \
-			$(WEB_PAGES) checktab.awk workman.sh \
+			$(WEB_PAGES) $(AWK_SCRIPTS) workman.sh \
 			zoneinfo2tdf.pl
 ENCHILADA=	$(COMMON) $(DOCS) $(SOURCES) $(DATA) $(MISC)
 # And for the benefit of csh users on systems that assume the user
 # shell should be used to handle commands in Makefiles. . .
 SHELL=		/bin/sh
-all:		tzselect zic zdump $(LIBOBJS)
+all:		tzselect zic zdump $(LIBOBJS) $(TABDATA)
 ALL:		all date
-install:	all $(DATA) $(REDO) $(TZLIB) $(MANS) $(TABDATA)
+install:	all $(DATA) $(REDO) $(DESTDIR)$(TZLIB) $(MANS)
 		$(ZIC) -y $(YEARISTYPE) \
-			-d $(TZDIR) -l $(LOCALTIME) -p $(POSIXRULES)
+			-d $(DESTDIR)$(TZDIR) -l $(LOCALTIME) -p $(POSIXRULES)
-		-rm -f $(TZDIR)/iso3166.tab $(TZDIR)/zone.tab
+		-rm -f $(DESTDIR)$(TZDIR)/iso3166.tab \
-		cp iso3166.tab zone.tab $(TZDIR)/.
+			$(DESTDIR)$(TZDIR)/zone.tab
-		-mkdir $(TOPDIR) $(ETCDIR)
+		cp iso3166.tab zone.tab $(DESTDIR)$(TZDIR)/.
-		cp tzselect zic zdump $(ETCDIR)/.
+		-mkdir $(DESTDIR)$(TOPDIR) $(DESTDIR)$(ETCDIR)
-		-mkdir $(TOPDIR) $(MANDIR) \
+		cp tzselect zic zdump $(DESTDIR)$(ETCDIR)/.
-			$(MANDIR)/man3 $(MANDIR)/man5 $(MANDIR)/man8
+		-mkdir $(DESTDIR)$(TOPDIR) $(DESTDIR)$(MANDIR) \
-		-rm -f $(MANDIR)/man3/newctime.3 \
+			$(DESTDIR)$(MANDIR)/man3 $(DESTDIR)$(MANDIR)/man5 \
-			$(MANDIR)/man3/newtzset.3 \
+			$(DESTDIR)$(MANDIR)/man8
-			$(MANDIR)/man5/tzfile.5 \
+		-rm -f $(DESTDIR)$(MANDIR)/man3/newctime.3 \
-			$(MANDIR)/man8/tzselect.8 \
+			$(DESTDIR)$(MANDIR)/man3/newtzset.3 \
-			$(MANDIR)/man8/zdump.8 \
+			$(DESTDIR)$(MANDIR)/man5/tzfile.5 \
-			$(MANDIR)/man8/zic.8
+			$(DESTDIR)$(MANDIR)/man8/tzselect.8 \
-		cp newctime.3 newtzset.3 $(MANDIR)/man3/.
+			$(DESTDIR)$(MANDIR)/man8/zdump.8 \
-		cp tzfile.5 $(MANDIR)/man5/.
+			$(DESTDIR)$(MANDIR)/man8/zic.8
-		cp tzselect.8 zdump.8 zic.8 $(MANDIR)/man8/.
+		cp newctime.3 newtzset.3 $(DESTDIR)$(MANDIR)/man3/.
 		cp tzfile.5 $(DESTDIR)$(MANDIR)/man5/.
 		cp tzselect.8 zdump.8 zic.8 $(DESTDIR)$(MANDIR)/man8/.
 INSTALL:	ALL install date.1
-		-mkdir $(TOPDIR) $(BINDIR)
+		-mkdir $(DESTDIR)$(TOPDIR) $(DESTDIR)$(BINDIR)
-		cp date $(BINDIR)/.
+		cp date $(DESTDIR)$(BINDIR)/.
-		-mkdir $(TOPDIR) $(MANDIR) $(MANDIR)/man1
+		-mkdir $(DESTDIR)$(TOPDIR) $(DESTDIR)$(MANDIR) \
-		-rm -f $(MANDIR)/man1/date.1
+			$(DESTDIR)$(MANDIR)/man1
-		cp date.1 $(MANDIR)/man1/.
+		-rm -f $(DESTDIR)$(MANDIR)/man1/date.1
 		cp date.1 $(DESTDIR)$(MANDIR)/man1/.
 version.h:
 		(echo 'static char const PKGVERSION[]="($(PACKAGE)) ";' && \
 		 echo 'static char const TZVERSION[]="$(VERSION)";' && \
 		 echo 'static char const REPORT_BUGS_TO[]="$(BUGEMAIL)";') >$@
 zdump:		$(TZDOBJS)
 		$(CC) -o $@ $(CFLAGS) $(LDFLAGS) $(TZDOBJS) $(LDLIBS)
 zic:		$(TZCOBJS) yearistype
 		$(CC) -o $@ $(CFLAGS) $(LDFLAGS) $(TZCOBJS) $(LDLIBS)
 yearistype:	yearistype.sh
 		cp yearistype.sh yearistype
 		chmod +x yearistype
 leapseconds:	leapseconds.awk leap-seconds.list
 		$(AWK) -f leapseconds.awk leap-seconds.list >$@
 posix_only:	zic $(TDATA)
-		$(ZIC) -y $(YEARISTYPE) -d $(TZDIR) -L /dev/null $(TDATA)
+		$(ZIC) -y $(YEARISTYPE) -d $(DESTDIR)$(TZDIR) \
 			-L /dev/null $(TDATA)
 right_only:	zic leapseconds $(TDATA)
-		$(ZIC) -y $(YEARISTYPE) -d $(TZDIR) -L leapseconds $(TDATA)
+		$(ZIC) -y $(YEARISTYPE) -d $(DESTDIR)$(TZDIR) \
 			-L leapseconds $(TDATA)
 # In earlier versions of this makefile, the other two directories were
 # subdirectories of $(TZDIR).  However, this led to configuration errors.
 # For example, with posix_right under the earlier scheme,
 # TZ='right/Australia/Adelaide' got you localtime with leap seconds,
 # but gmtime without leap seconds, which led to problems with applications
 # like sendmail that subtract gmtime from localtime.
 # Therefore, the other two directories are now siblings of $(TZDIR).
 # You must replace all of $(TZDIR) to switch from not using leap seconds
 # to using them, or vice versa.
-other_two:	zic leapseconds $(TDATA)
+right_posix:	right_only leapseconds
-		$(ZIC) -y $(YEARISTYPE) -d $(TZDIR)-posix -L /dev/null $(TDATA)
+		rm -fr $(DESTDIR)$(TZDIR)-leaps
-		$(ZIC) -y $(YEARISTYPE) \
+		ln -s $(TZDIR_BASENAME) $(DESTDIR)$(TZDIR)-leaps || \
-			-d $(TZDIR)-leaps -L leapseconds $(TDATA)
+		  $(ZIC) -y $(YEARISTYPE) -d $(DESTDIR)$(TZDIR)-leaps \
 			-L leapseconds $(TDATA)
-posix_right:	posix_only other_two
+		$(ZIC) -y $(YEARISTYPE) -d $(DESTDIR)$(TZDIR)-posix \
 			-L /dev/null $(TDATA)
 right_posix:	right_only other_two
 posix_right:	posix_only leapseconds
 		rm -fr $(DESTDIR)$(TZDIR)-posix
 		ln -s $(TZDIR_BASENAME) $(DESTDIR)$(TZDIR)-posix || \
 		  $(ZIC) -y $(YEARISTYPE) -d $(DESTDIR)$(TZDIR)-posix \
 			-L /dev/null $(TDATA)
 		$(ZIC) -y $(YEARISTYPE) -d $(DESTDIR)$(TZDIR)-leaps \
 			-L leapseconds $(TDATA)
 zones:		$(REDO)
-$(TZLIB):	$(LIBOBJS)
+$(DESTDIR)$(TZLIB): $(LIBOBJS)
-		-mkdir $(TOPDIR) $(LIBDIR)
+		-mkdir -p $(DESTDIR)$(TOPDIR) $(DESTDIR)$(LIBDIR)
 		ar ru $@ $(LIBOBJS)
 		if [ -x /usr/ucb/ranlib ] || [ -x /usr/bin/ranlib ]; \
 			then ranlib $@ ; fi
 date:		$(DATEOBJS)
 		$(CC) -o $@ $(CFLAGS) $(LDFLAGS) $(DATEOBJS) $(LDLIBS)
 tzselect:	tzselect.ksh
 		sed \
 			-e 's|#!/bin/bash|#!$(KSHELL)|g' \
 			-e 's|AWK=[^}]*|AWK=$(AWK)|g' \
 			-e 's|\(PKGVERSION\)=.*|\1='\''($(PACKAGE)) '\''|' \
 			-e 's|\(REPORT_BUGS_TO\)=.*|\1=$(BUGEMAIL)|' \
 @@ -425,27 +444,27 @@ tzselect:	tzselect.ksh
 check:		check_character_set check_tables check_web
 check_character_set: $(ENCHILADA)
 		sharp='#'; ! grep -n $(INVALID_CHAR) $(ENCHILADA)
 check_tables:	checktab.awk $(PRIMARY_YDATA)
 		$(AWK) -f checktab.awk $(PRIMARY_YDATA)
 check_web:	$(WEB_PAGES)
 		$(VALIDATE_ENV) $(VALIDATE) $(VALIDATE_FLAGS) $(WEB_PAGES)
 clean_misc:
 		rm -f core *.o *.out \
-		  date tzselect version.h zdump zic yearistype
+		  date leapseconds tzselect version.h zdump zic yearistype
 clean:		clean_misc
 		rm -f -r tzpublic
 maintainer-clean: clean
 		@echo 'This command is intended for maintainers to use; it'
 		@echo 'deletes files that may need special tools to rebuild.'
 		rm -f *.[1-8].txt *.asc *.tar.gz
 names:
 		@echo $(ENCHILADA)
 public:		check check_public check_time_t_alternatives \
 		set-timestamps tarballs signatures
 @@ -525,27 +544,27 @@ tzdata$(VERSION).tar.gz: $(COMMON) $(DAT
 		tar $(TARFLAGS) -cf - $(COMMON) $(DATA) | \
 		  gzip $(GZIPFLAGS) > $@
 signatures:	tzcode$(VERSION).tar.gz.asc tzdata$(VERSION).tar.gz.asc
 tzcode$(VERSION).tar.gz.asc: tzcode$(VERSION).tar.gz
 		gpg --armor --detach-sign $?
 tzdata$(VERSION).tar.gz.asc: tzdata$(VERSION).tar.gz
 		gpg --armor --detach-sign $?
 typecheck:
 		make clean
-		for i in "long long" unsigned double; \
+		for i in "long long" unsigned; \
 		do \
 			make CFLAGS="-DTYPECHECK -D__time_t_defined -D_TIME_T \"-Dtime_t=$$i\"" ; \
 			./zdump -v Europe/Rome ; \
 			make clean ; \
 		done
 zonenames:	$(TDATA)
 		@$(AWK) '/^Zone/ { print $$2 } /^Link/ { print $$3 }' $(TDATA)
 asctime.o:	private.h tzfile.h
 date.o:		private.h
 difftime.o:	private.h
 ialloc.o:	private.h

--- src/lib/libc/time/difftime.c 2013/07/17 20:13:04	1.14
+++ src/lib/libc/time/difftime.c 2013/09/20 19:06:54	1.15

 @@ -1,63 +1,54 @@
-/*	$NetBSD: difftime.c,v 1.14 2013/07/17 20:13:04 christos Exp $	*/
+/*	$NetBSD: difftime.c,v 1.15 2013/09/20 19:06:54 christos Exp $	*/
 /*
 ** This file is in the public domain, so clarified as of
 ** 1996-06-05 by Arthur David Olson.
 */
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
 #if 0
 static char	elsieid[] = "@(#)difftime.c	8.1";
 #else
-__RCSID("$NetBSD: difftime.c,v 1.14 2013/07/17 20:13:04 christos Exp $");
+__RCSID("$NetBSD: difftime.c,v 1.15 2013/09/20 19:06:54 christos Exp $");
 #endif
 #endif /* LIBC_SCCS and not lint */
 /*LINTLIBRARY*/
-#include "private.h"	/* for time_t, TYPE_INTEGRAL, and TYPE_SIGNED */
+#include "private.h"	/* for time_t and TYPE_SIGNED */
 double ATTRIBUTE_CONST
 difftime(const time_t time1, const time_t time0)
+{
 	/*
 	** If (sizeof (double) > sizeof (time_t)) simply convert and subtract
 	** (assuming that the larger type has more precision).
 	*/
 	/*CONSTCOND*/
 	if (sizeof (double) > sizeof (time_t))
 		return (double) time1 - (double) time0;
 	/*LINTED const not */
 	if (!TYPE_INTEGRAL(time_t)) {
 		/*
 		** time_t is floating.
 		*/
 		return time1 - time0;
 	/*LINTED const not */
 	if (!TYPE_SIGNED(time_t)) {
 		/*
 		** time_t is integral and unsigned.
 		** The difference of two unsigned values can't overflow
 		** if the minuend is greater than or equal to the subtrahend.
 		*/
 		if (time1 >= time0)
 			return            time1 - time0;
 		else	return -(double) (time0 - time1);
+	}
 	/*
 	** time_t is integral and signed.
 	** Handle cases where both time1 and time0 have the same sign
 	** (meaning that their difference cannot overflow).
 	*/
 	if ((time1 < 0) == (time0 < 0))
 		return time1 - time0;
 	/*
 	** time1 and time0 have opposite signs.
 	** Punt if uintmax_t is too narrow.
 	** This suffers from double rounding; attempt to lessen that
 	** by using long double temporaries.
 	*/
 	/* CONSTCOND */
 	if (sizeof (uintmax_t) < sizeof (time_t))

--- src/lib/libc/time/Theory 2013/07/17 20:13:04	1.13
+++ src/lib/libc/time/Theory 2013/09/20 19:06:54	1.14

 @@ -2,79 +2,80 @@ This file is in the public domain, so cl
 -05-17 by Arthur David Olson.
 ----- Outline -----
 	Time and date functions
 	Scope of the tz database
 	Names of time zone rule files
 	Time zone abbreviations
 	Calendrical issues
 	Time and time zones on Mars
 ----- Time and date functions -----
-These time and date functions are upwards compatible with POSIX,
+These time and date functions are upwards compatible with those of POSIX,
 an international standard for UNIX-like systems.
 As of this writing, the current edition of POSIX is:
-  Standard for Information technology
+  The Open Group Base Specifications Issue 7
-  -- Portable Operating System Interface (POSIX (R))
+  IEEE Std 1003.1, 2013 Edition
-  -- System Interfaces
+  <http://pubs.opengroup.org/onlinepubs/9699919799/>
   IEEE Std 1003.1, 2004 Edition
   <http://www.opengroup.org/online-pubs?DOC=7999959899>
   <http://www.opengroup.org/pubs/catalog/t041.htm>
 POSIX has the following properties and limitations.
 *	In POSIX, time display in a process is controlled by the
 	environment variable TZ.  Unfortunately, the POSIX TZ string takes
 	a form that is hard to describe and is error-prone in practice.
 	Also, POSIX TZ strings can't deal with other (for example, Israeli)
 	daylight saving time rules, or situations where more than two
 	time zone abbreviations are used in an area.
 	The POSIX TZ string takes the following form:
-		stdoffset[dst[offset],date[/time],date[/time]]
+		stdoffset[dst[offset][,date[/time],date[/time]]]
 	where:
 	std and dst
 		are 3 or more characters specifying the standard
 		and daylight saving time (DST) zone names.
 		Starting with POSIX.1-2001, std and dst may also be
 		in a quoted form like "<UTC+10>"; this allows
 		"+" and "-" in the names.
 	offset
-		is of the form `[-]hh:[mm[:ss]]' and specifies the
+		is of the form '[+-]hh:[mm[:ss]]' and specifies the
-		offset west of UTC.  The default DST offset is one hour
+		offset west of UT.  'hh' may be a single digit; 0<=hh<=24.
-		ahead of standard time.
+		The default DST offset is one hour ahead of standard time.
 	date[/time],date[/time]
 		specifies the beginning and end of DST.  If this is absent,
 		the system supplies its own rules for DST, and these can
 		differ from year to year; typically US DST rules are used.
 	time
-		takes the form `hh:[mm[:ss]]' and defaults to 02:00.
+		takes the form 'hh:[mm[:ss]]' and defaults to 02:00.
 		This is the same format as the offset, except that a
 		leading '+' or '-' is not allowed.
 	date
 		takes one of the following forms:
 		Jn (1<=n<=365)
 			origin-1 day number not counting February 29
 		n (0<=n<=365)
 			origin-0 day number counting February 29 if present
 		Mm.n.d (0[Sunday]<=d<=6[Saturday], 1<=n<=5, 1<=m<=12)
 			for the dth day of week n of month m of the year,
 			where week 1 is the first week in which day d appears,
-			and `5' stands for the last week in which day d appears
+			and '5' stands for the last week in which day d appears
 			(which may be either the 4th or 5th week).
 			Typically, this is the only useful form;
 			the n and Jn forms are rarely used.
 	Here is an example POSIX TZ string, for US Pacific time using rules
 	appropriate from 1987 through 2006:
 		TZ='PST8PDT,M4.1.0/02:00,M10.5.0/02:00'
 	This POSIX TZ string is hard to remember, and mishandles time stamps
 	before 1987 and after 2006.  With this package you can use this
 	instead:
 		TZ='America/Los_Angeles'
 *	POSIX does not define the exact meaning of TZ values like "EST5EDT".
 @@ -85,26 +86,39 @@ POSIX has the following properties and l
 	do time conversion must be recompiled to ensure proper results.
 *	In POSIX, there's no tamper-proof way for a process to learn the
 	system's best idea of local wall clock.  (This is important for
 	applications that an administrator wants used only at certain times--
 	without regard to whether the user has fiddled the "TZ" environment
 	variable.  While an administrator can "do everything in UTC" to get
 	around the problem, doing so is inconvenient and precludes handling
 	daylight saving time shifts--as might be required to limit phone
 	calls to off-peak hours.)
 *	POSIX requires that systems ignore leap seconds.
 *	The tz code attempts attempts to support all the time_t implementations
 	allowed by POSIX.  The time_t type represents a nonnegative count of
 	seconds since 1970-01-01 00:00:00 UTC, ignoring leap seconds.
 	In practice, time_t is usually a signed 64- or 32-bit integer; 32-bit
 	signed time_t values stop working after 2038-01-19 03:14:07 UTC, so
 	new implementations these days typically use a signed 64-bit integer.
 	Unsigned 32-bit integers are used on one or two platforms,
 	and 36-bit integers are also used occasionally.
 	Although earlier POSIX versions allowed time_t to be a
 	floating-point type, this was not supported by any practical
 	systems, and POSIX.1-2013 and the tz code both require time_t
 	to be an integer type.
 These are the extensions that have been made to the POSIX functions:
 *	The "TZ" environment variable is used in generating the name of a file
 	from which time zone information is read (or is interpreted a la
 	POSIX); "TZ" is no longer constrained to be a three-letter time zone
 	name followed by a number of hours and an optional three-letter
 	daylight time zone name.  The daylight saving time rules to be used
 	for a particular time zone are encoded in the time zone file;
 	the format of the file allows U.S., Australian, and other rules to be
 	encoded, and allows for situations where more than two time zone
 	abbreviations are used.
 	It was recognized that allowing the "TZ" environment variable to
 @@ -136,96 +150,223 @@ These are the extensions that have been
 	source code tells how to get compatibly wrong results).
 *	A function "tzsetwall" has been added to arrange for the system's
 	best approximation to local wall clock time to be delivered by
 	subsequent calls to "localtime."  Source code for portable
 	applications that "must" run on local wall clock time should call
 	"tzsetwall();" if such code is moved to "old" systems that don't
 	provide tzsetwall, you won't be able to generate an executable program.
 	(These time zone functions also arrange for local wall clock time to be
 	used if tzset is called--directly or indirectly--and there's no "TZ"
 	environment variable; portable applications should not, however, rely
 	on this behavior since it's not the way SVR2 systems behave.)
 *	Negative time_t values are supported, on systems where time_t is signed.
 *	These functions can account for leap seconds, thanks to Bradley White.
 Points of interest to folks with other systems:
 *	This package is already part of many POSIX-compliant hosts,
 	including BSD, HP, Linux, Network Appliance, SCO, SGI, and Sun.
 	On such hosts, the primary use of this package
 	is to update obsolete time zone rule tables.
 	To do this, you may need to compile the time zone compiler
-	`zic' supplied with this package instead of using the system `zic',
+	'zic' supplied with this package instead of using the system 'zic',
 	since the format of zic's input changed slightly in late 1994,
 	and many vendors still do not support the new input format.
 *	The UNIX Version 7 "timezone" function is not present in this package;
 	it's impossible to reliably map timezone's arguments (a "minutes west
 	of GMT" value and a "daylight saving time in effect" flag) to a
 	time zone abbreviation, and we refuse to guess.
 	Programs that in the past used the timezone function may now examine
 	tzname[localtime(&clock)->tm_isdst] to learn the correct time
 	zone abbreviation to use.  Alternatively, use
 	localtime(&clock)->tm_zone if this has been enabled.
 *	The 4.2BSD gettimeofday function is not used in this package.
 	This formerly let users obtain the current UTC offset and DST flag,
 	but this functionality was removed in later versions of BSD.
 *	In SVR2, time conversion fails for near-minimum or near-maximum
-	time_t values when doing conversions for places that don't use UTC.
+	time_t values when doing conversions for places that don't use UT.
 	This package takes care to do these conversions correctly.
 The functions that are conditionally compiled if STD_INSPIRED is defined
 should, at this point, be looked on primarily as food for thought.  They are
 not in any sense "standard compatible"--some are not, in fact, specified in
 *any* standard.  They do, however, represent responses of various authors to
 standardization proposals.
 Other time conversion proposals, in particular the one developed by folks at
 Hewlett Packard, offer a wider selection of functions that provide capabilities
 beyond those provided here.  The absence of such functions from this package
 is not meant to discourage the development, standardization, or use of such
 functions.  Rather, their absence reflects the decision to make this package
 contain valid extensions to POSIX, to ensure its broad acceptability.  If
 more powerful time conversion functions can be standardized, so much the
 better.
 ----- Scope of the tz database -----
 The tz database attempts to record the history and predicted future of
 all computer-based clocks that track civil time.  To represent this
 data, the world is partitioned into regions whose clocks all agree
 about time stamps that occur after the somewhat-arbitrary cutoff point
 of the POSIX Epoch (1970-01-01 00:00:00 UTC).  For each such region,
 the database records all known clock transitions, and labels the region
-with a notable location.
+with a notable location.  Although 1970 is a somewhat-arbitrary
 cutoff, there are significant challenges to moving the cutoff earlier
 even by a decade or two, due to the wide variety of local practices
 before computer timekeeping became prevalent.
 Clock transitions before 1970 are recorded for each such location,
 because most POSIX-compatible systems support negative time stamps and
 could misbehave if data were omitted for pre-1970 transitions.
 However, the database is not designed for and does not suffice for
 applications requiring accurate handling of all past times everywhere,
 as it would take far too much effort and guesswork to record all
 details of pre-1970 civil timekeeping.
 As noted in the README file, the tz database is not authoritative
-(particularly not for pre-1970 time stamps), and it surely has errors.
+----- Accuracy of the tz database -----
 The tz database is not authoritative, and it surely has errors.
 Corrections are welcome and encouraged.  Users requiring authoritative
 data should consult national standards bodies and the references cited
 in the database's comments.
 Errors in the tz database arise from many sources:
  * The tz database predicts future time stamps, and current predictions
    will be incorrect after future governments change the rules.
    For example, if today someone schedules a meeting for 13:00 next
    October 1, Casablanca time, and tomorrow Morocco changes its
    daylight saving rules, software can mess up after the rule change
    if it blithely relies on conversions made before the change.
  * The pre-1970 data in this database cover only a tiny sliver of how
    clocks actually behaved; the vast majority of the necessary
    information was lost or never recorded.  Thousands more zones would
    be needed if the tz database's scope were extended to cover even
    just the known or guessed history of standard time; for example,
    the current single entry for France would need to split into dozens
    of entries, perhaps hundreds.
  * Most of the pre-1970 data comes from unreliable sources, often
    astrology books that lack citations and whose compilers evidently
    invented entries when the true facts were unknown, without
    reporting which entries were known and which were invented.
    These books often contradict each other or give implausible entries,
    and on the rare occasions when their old data are checked they are
    typically found to be incorrect.
  * For the UK the tz database relies on years of first-class work done by
    Joseph Myers and others; see <http://www.polyomino.org.uk/british-time/>.
    Other countries are not done nearly as well.
  * Sometimes, different people in the same city would maintain clocks
    that differed significantly.  Railway time was used by railroad
    companies (which did not always agree with each other),
    church-clock time was used for birth certificates, etc.
    Often this was merely common practice, but sometimes it was set by law.
    For example, from 1891 to 1911 the UT offset in France was legally
 :09:21 outside train stations and 0:04:21 inside.
  * Although a named location in the tz database stands for the
    containing region, its pre-1970 data entries are often accurate for
    only a small subset of that region.  For example, Europe/London
    stands for the United Kingdom, but its pre-1847 times are valid
    only for locations that have London's exact meridian, and its 1847
    transition to GMT is known to be valid only for the L&NW and the
    Caledonian railways.
  * The tz database does not record the earliest time for which a
    zone's data is thereafter valid for every location in the region.
    For example, Europe/London is valid for all locations in its
    region after GMT was made the standard time, but the date of
    standardization (1880-08-02) is not in the tz database, other than
    in commentary.  For many zones the earliest time of validity is
    unknown.
  * The tz database does not record a region's boundaries, and in many
    cases the boundaries are not known.  For example, the zone
    America/Kentucky/Louisville represents a region around the city of
    Louisville, the boundaries of which are unclear.
  * Changes that are modeled as instantaneous transitions in the tz
    database were often spread out over hours, days, or even decades.
  * Even if the time is specified by law, locations sometimes
    deliberately flout the law.
  * Early timekeeping practices, even assuming perfect clocks, were
    often not specified to the accuracy that the tz database requires.
  * Sometimes historical timekeeping was specified more precisely
    than what the tz database can handle.  For example, from 1909 to
 Netherlands clocks were legally UT+00:19:32.13, but the tz
    database cannot represent the fractional second.
  * Even when all the timestamp transitions recorded by the tz database
    are correct, the tz rules that generate them may not faithfully
    reflect the historical rules.  For example, from 1922 until World
    War II the UK moved clocks forward the day following the third
    Saturday in April unless that was Easter, in which case it moved
    clocks forward the previous Sunday.  Because the tz database has no
    way to specify Easter, these exceptional years are entered as
    separate tz Rule lines, even though the legal rules did not change.
  * The tz database models pre-standard time using the Gregorian
    calendar and local mean time (LMT), but many people used other
    calendars and other timescales.  For example, the Roman Empire used
    the Julian calendar, and had 12 varying-length daytime hours with a
    non-hour-based system at night.
  * Early clocks were less reliable, and the data do not represent this
    unreliability.
  * As for leap seconds, civil time was not based on atomic time before
 , and we don't know the history of earth's rotation accurately
    enough to map SI seconds to historical solar time to more than
    about one-hour accuracy.  See: Morrison LV, Stephenson FR.
    Historical values of the Earth's clock error Delta T and the
    calculation of eclipses. J Hist Astron. 2004;35:327-36
    <http://adsabs.harvard.edu/full/2004JHA....35..327M>;
    Historical values of the Earth's clock error. J Hist Astron. 2005;36:339
    <http://adsabs.harvard.edu/full/2005JHA....36..339M>.
  * The relationship between POSIX time (that is, UTC but ignoring leap
    seconds) and UTC is not agreed upon after 1972.  Although the POSIX
    clock officially stops during an inserted leap second, at least one
    proposed standard has it jumping back a second instead; and in
    practice POSIX clocks more typically either progress glacially during
    a leap second, or are slightly slowed while near a leap second.
  * The tz database does not represent how uncertain its information is.
    Ideally it would contain information about when the data are
    incomplete or dicey.  Partial temporal knowledge is a field of
    active research, though, and it's not clear how to apply it here.
 In short, many, perhaps most, of the tz database's pre-1970 and future
 time stamps are either wrong or misleading.  Any attempt to pass the
 tz database off as the definition of time should be unacceptable to
 anybody who cares about the facts.  In particular, the tz database's
 LMT offsets should not be considered meaningful, and should not prompt
 creation of zones merely because two locations differ in LMT or
 transitioned to standard time at different dates.
 ----- Names of time zone rule files -----
 The time zone rule file naming conventions attempt to strike a balance
 among the following goals:
  * Uniquely identify every national region where clocks have all
    agreed since 1970.  This is essential for the intended use: static
    clocks keeping local civil time.
  * Indicate to humans as to where that region is.  This simplifies use.
  * Be robust in the presence of political changes.  This reduces the
 @@ -241,177 +382,193 @@ among the following goals:
  * Use a consistent naming convention over the entire world.
    This simplifies both use and maintenance.
 This naming convention is not intended for use by inexperienced users
 to select TZ values by themselves (though they can of course examine
 and reuse existing settings).  Distributors should provide
 documentation and/or a simple selection interface that explains the
 names; see the 'tzselect' program supplied with this distribution for
 one example.
 Names normally have the form AREA/LOCATION, where AREA is the name
 of a continent or ocean, and LOCATION is the name of a specific
 location within that region.  North and South America share the same
-area, `America'.  Typical names are `Africa/Cairo', `America/New_York',
+area, 'America'.  Typical names are 'Africa/Cairo', 'America/New_York',
-and `Pacific/Honolulu'.
+and 'Pacific/Honolulu'.
 Here are the general rules used for choosing location names,
 in decreasing order of importance:
 	Use only valid POSIX file name components (i.e., the parts of
-		names other than `/').  Within a file name component,
+		names other than '/').  Do not use the file name
-		use only ASCII letters, `.', `-' and `_'.  Do not use
+		components '.' and '..'.  Within a file name component,
 		use only ASCII letters, '.', '-' and '_'.  Do not use
 		digits, as that might create an ambiguity with POSIX
 		TZ strings.  A file name component must not exceed 14
-		characters or start with `-'.  E.g., prefer `Brunei'
+		characters or start with '-'.  E.g., prefer 'Brunei'
-		to `Bandar_Seri_Begawan'.
+		to 'Bandar_Seri_Begawan'.
 	A name must not be empty, or contain '//', or start or end with '/'.
 	Do not use names that differ only in case.  Although the reference
-	        implementation is case-sensitive, some other implementations
+		implementation is case-sensitive, some other implementations
 		are not, and they would mishandle names differing only in case.
 	If one name A is an initial prefix of another name AB (ignoring case),
 		then B must not start with '/', as a regular file cannot have
 		the same name as a directory in POSIX.  For example,
 		'America/New_York' precludes 'America/New_York/Bronx'.
 	Uninhabited regions like the North Pole and Bouvet Island
 		do not need locations, since local time is not defined there.
 	There should typically be at least one name for each ISO 3166-1
 		officially assigned two-letter code for an inhabited country
 		or territory.
 	If all the clocks in a region have agreed since 1970,
 		don't bother to include more than one location
 		even if subregions' clocks disagreed before 1970.
 		Otherwise these tables would become annoyingly large.
 	If a name is ambiguous, use a less ambiguous alternative;
 		e.g. many cities are named San Jose and Georgetown, so
-		prefer `Costa_Rica' to `San_Jose' and `Guyana' to `Georgetown'.
+		prefer 'Costa_Rica' to 'San_Jose' and 'Guyana' to 'Georgetown'.
 	Keep locations compact.  Use cities or small islands, not countries
 		or regions, so that any future time zone changes do not split
-		locations into different time zones.  E.g. prefer `Paris'
+		locations into different time zones.  E.g. prefer 'Paris'
-		to `France', since France has had multiple time zones.
+		to 'France', since France has had multiple time zones.
-	Use mainstream English spelling, e.g. prefer `Rome' to `Roma', and
+	Use mainstream English spelling, e.g. prefer 'Rome' to 'Roma', and
-		prefer `Athens' to the true name (which uses Greek letters).
+		prefer 'Athens' to the true name (which uses Greek letters).
 		The POSIX file name restrictions encourage this rule.
 	Use the most populous among locations in a zone,
-		e.g. prefer `Shanghai' to `Beijing'.  Among locations with
+		e.g. prefer 'Shanghai' to 'Beijing'.  Among locations with
 		similar populations, pick the best-known location,
-		e.g. prefer `Rome' to `Milan'.
+		e.g. prefer 'Rome' to 'Milan'.
-	Use the singular form, e.g. prefer `Canary' to `Canaries'.
+	Use the singular form, e.g. prefer 'Canary' to 'Canaries'.
-	Omit common suffixes like `_Islands' and `_City', unless that
+	Omit common suffixes like '_Islands' and '_City', unless that
-		would lead to ambiguity.  E.g. prefer `Cayman' to
+		would lead to ambiguity.  E.g. prefer 'Cayman' to
-		`Cayman_Islands' and `Guatemala' to `Guatemala_City',
+		'Cayman_Islands' and 'Guatemala' to 'Guatemala_City',
-		but prefer `Mexico_City' to `Mexico' because the country
+		but prefer 'Mexico_City' to 'Mexico' because the country
 		of Mexico has several time zones.
-	Use `_' to represent a space.
+	Use '_' to represent a space.
-	Omit `.' from abbreviations in names, e.g. prefer `St_Helena'
+	Omit '.' from abbreviations in names, e.g. prefer 'St_Helena'
-		to `St._Helena'.
+		to 'St._Helena'.
 	Do not change established names if they only marginally
 		violate the above rules.  For example, don't change
-		the existing name `Rome' to `Milan' merely because
+		the existing name 'Rome' to 'Milan' merely because
 		Milan's population has grown to be somewhat greater
 		than Rome's.
-	If a name is changed, put its old spelling in the `backward' file.
+	If a name is changed, put its old spelling in the 'backward' file.
 		This means old spellings will continue to work.
-The file `zone.tab' lists the geographical locations used to name
+The file 'zone.tab' lists geographical locations used to name time
-time zone rule files.  It is intended to be an exhaustive list
+zone rule files.  It is intended to be an exhaustive list of names
-of names for geographic regions as described above.
+for geographic regions as described above; this is a subset of the
 names in the data.  Although a 'zone.tab' location's longitude
 corresponds to its LMT offset with one hour for every 15 degrees east
 longitude, this relationship is not exact.
 Older versions of this package used a different naming scheme,
 and these older names are still supported.
-See the file `backward' for most of these older names
+See the file 'backward' for most of these older names
-(e.g. `US/Eastern' instead of `America/New_York').
+(e.g. 'US/Eastern' instead of 'America/New_York');
 excluding 'backward' should not affect the other data.
 The other old-fashioned names still supported are
-`WET', `CET', `MET', and `EET' (see the file `europe').
+'WET', 'CET', 'MET', and 'EET' (see the file 'europe').
 ----- Time zone abbreviations -----
 When this package is installed, it generates time zone abbreviations
-like `EST' to be compatible with human tradition and POSIX.
+like 'EST' to be compatible with human tradition and POSIX.
 Here are the general rules used for choosing time zone abbreviations,
 in decreasing order of importance:
 	Use abbreviations that consist of three or more ASCII letters.
 		Previous editions of this database also used characters like
 		' ' and '?', but these characters have a special meaning to
 		the shell and cause commands like
 			set `date`
 		to have unexpected effects.
 		Previous editions of this rule required upper-case letters,
 		but the Congressman who introduced Chamorro Standard Time
 		preferred "ChST", so the rule has been relaxed.
 		This rule guarantees that all abbreviations could have
 		been specified by a POSIX TZ string.  POSIX
 		requires at least three characters for an
 		abbreviation.  POSIX through 2000 says that an abbreviation
 		cannot start with ':', and cannot contain ',', '-',
 		'+', NUL, or a digit.  POSIX from 2001 on changes this
 		rule to say that an abbreviation can contain only '-', '+',
 		and alphanumeric characters from the portable character set
 		in the current locale.  To be portable to both sets of
 		rules, an abbreviation must therefore use only ASCII
 		letters.
 	Use abbreviations that are in common use among English-speakers,
-		e.g. `EST' for Eastern Standard Time in North America.
+		e.g. 'EST' for Eastern Standard Time in North America.
 		We assume that applications translate them to other languages
 		as part of the normal localization process; for example,
-		a French application might translate `EST' to `HNE'.
+		a French application might translate 'EST' to 'HNE'.
 	For zones whose times are taken from a city's longitude, use the
-		traditional xMT notation, e.g. `PMT' for Paris Mean Time.
+		traditional xMT notation, e.g. 'PMT' for Paris Mean Time.
-		The only name like this in current use is `GMT'.
+		The only name like this in current use is 'GMT'.
 	If there is no common English abbreviation, abbreviate the English
 		translation of the usual phrase used by native speakers.
 		If this is not available or is a phrase mentioning the country
-		(e.g. ``Cape Verde Time''), then:
+		(e.g. "Cape Verde Time"), then:
 		When a country is identified with a single or principal zone,
-			append `T' to the country's ISO	code, e.g. `CVT' for
+			append 'T' to the country's ISO	code, e.g. 'CVT' for
-			Cape Verde Time.  For summer time append `ST';
+			Cape Verde Time.  For summer time append 'ST';
-			for double summer time append `DST'; etc.
+			for double summer time append 'DST'; etc.
 		Otherwise, take the first three letters of an English place
 			name identifying each zone and append 'T', 'ST', etc.
 			as before; e.g. 'VLAST' for VLAdivostok Summer Time.
-	Use UTC (with time zone abbreviation "zzz") for locations while
+	Use 'LMT' for local mean time of locations before the introduction
-		uninhabited.  The "zzz" mnemonic is that these locations are,
+		of standard time; see "Scope of the tz database".
 	Use UT (with time zone abbreviation 'zzz') for locations while
 		uninhabited.  The 'zzz' mnemonic is that these locations are,
 		in some sense, asleep.
 Application writers should note that these abbreviations are ambiguous
-in practice: e.g. `EST' has a different meaning in Australia than
+in practice: e.g. 'EST' has a different meaning in Australia than
 it does in the United States.  In new applications, it's often better
-to use numeric UTC offsets like `-0500' instead of time zone
+to use numeric UT offsets like '-0500' instead of time zone
-abbreviations like `EST'; this avoids the ambiguity.
+abbreviations like 'EST'; this avoids the ambiguity.
 ----- Calendrical issues -----
 Calendrical issues are a bit out of scope for a time zone database,
 but they indicate the sort of problems that we would run into if we
 extended the time zone database further into the past.  An excellent
 resource in this area is Nachum Dershowitz and Edward M. Reingold,
 <a href="http://emr.cs.iit.edu/home/reingold/calendar-book/third-edition/">
 Calendrical Calculations: Third Edition
 </a>, Cambridge University Press (2008).  Other information and
 sources are given below.  They sometimes disagree.
 France
 Gregorian calendar adopted 1582-12-20.
 French Revolutionary calendar used 1793-11-24 through 1805-12-31,
 and (in Paris only) 1871-05-06 through 1871-05-23.
 Russia
 From Chris Carrier (1996-12-02):
-On 1929-10-01 the Soviet Union instituted an ``Eternal Calendar''
+On 1929-10-01 the Soviet Union instituted an "Eternal Calendar"
 with 30-day months plus 5 holidays, with a 5-day week.
 On 1931-12-01 it changed to a 6-day week; in 1934 it reverted to the
 Gregorian calendar while retaining the 6-day week; on 1940-06-27 it
 reverted to the 7-day week.  With the 6-day week the usual days
 off were the 6th, 12th, 18th, 24th and 30th of the month.
 (Source: Evitiar Zerubavel, _The Seven Day Circle_)
 Mark Brader reported a similar story in "The Book of Calendars", edited
 by Frank Parise (1982, Facts on File, ISBN 0-8719-6467-8), page 377.  But:
 From: Petteri Sulonen (via Usenet)
 Date: 14 Jan 1999 00:00:00 GMT

--- src/lib/libc/time/checktab.awk 2012/08/09 12:38:25	1.5
+++ src/lib/libc/time/checktab.awk 2013/09/20 19:06:54	1.6

 @@ -1,26 +1,29 @@
-#	$NetBSD: checktab.awk,v 1.5 2012/08/09 12:38:25 christos Exp $
+#	$NetBSD: checktab.awk,v 1.6 2013/09/20 19:06:54 christos Exp $
 # Check tz tables for consistency.
 # Contributed by Paul Eggert.
 BEGIN {
 	FS = "\t"
 	if (!iso_table) iso_table = "iso3166.tab"
 	if (!zone_table) zone_table = "zone.tab"
 	if (!want_warnings) want_warnings = -1
 	# A special (and we hope temporary) case.
 	tztab["America/Montreal"] = 1
 	while (getline <iso_table) {
 		iso_NR++
 		if ($0 ~ /^#/) continue
 		if (NF != 2) {
 			printf "%s:%d: wrong number of columns\n", \
 				iso_table, iso_NR >>"/dev/stderr"
 			status = 1
+		}
 		cc = $1
 		name = $2
 		if (cc !~ /^[A-Z][A-Z]$/) {
 			printf "%s:%d: invalid country code `%s'\n", \
 				iso_table, iso_NR, cc >>"/dev/stderr"
 @@ -61,83 +64,83 @@ BEGIN {
 				zone_table, zone_NR >>"/dev/stderr"
 			status = 1
+		}
 		cc = $1
 		coordinates = $2
 		tz = $3
 		comments = $4
 		if (cc < cc0) {
 			printf "%s:%d: country code `%s' is out of order\n", \
 				zone_table, zone_NR, cc >>"/dev/stderr"
 			status = 1
+		}
 		cc0 = cc
-		if (tz2cc[tz]) {
+		cctz = cc tz
-			printf "%s:%d: %s: duplicate TZ column\n", \
+		cctztab[cctz] = 1
-				zone_table, zone_NR, tz >>"/dev/stderr"
+		tztab[tz] = 1
-			status = 1
+		tz2comments[cctz] = comments
 		tz2cc[tz] = cc
 		tz2comments[tz] = comments
 		tz2NR[tz] = zone_NR
 		if (cc2name[cc]) {
 			cc_used[cc]++
 		} else {
 			printf "%s:%d: %s: unknown country code\n", \
 				zone_table, zone_NR, cc >>"/dev/stderr"
 			status = 1
+		}
 		if (coordinates !~ /^[-+][0-9][0-9][0-5][0-9][-+][01][0-9][0-9][0-5][0-9]$/ \
 		    && coordinates !~ /^[-+][0-9][0-9][0-5][0-9][0-5][0-9][-+][01][0-9][0-9][0-5][0-9][0-5][0-9]$/) {
 			printf "%s:%d: %s: invalid coordinates\n", \
 				zone_table, zone_NR, coordinates >>"/dev/stderr"
 			status = 1
+		}
+	}
-	for (tz in tz2cc) {
+	for (cctz in cctztab) {
-		if (cc_used[tz2cc[tz]] == 1) {
+		cc = substr (cctz, 1, 2)
-			if (tz2comments[tz]) {
+		tz = substr (cctz, 3)
 		if (cc_used[cc] == 1) {
 			if (tz2comments[cctz]) {
 				printf "%s:%d: unnecessary comment `%s'\n", \
-					zone_table, tz2NR[tz], tz2comments[tz] \
+					zone_table, tz2NR[tz], \
 					tz2comments[cctz] \
 					>>"/dev/stderr"
 				status = 1
+			}
 		} else {
-			if (!tz2comments[tz]) {
+			if (!tz2comments[cctz]) {
 				printf "%s:%d: missing comment\n", \
 					zone_table, tz2NR[tz] >>"/dev/stderr"
 				status = 1
+			}
+		}
+	}
 	FS = " "
+}
+{
 	tz = ""
 	if ($1 == "Zone") tz = $2
 	if ($1 == "Link") {
 		# Ignore Link commands if source and destination basenames
 		# are identical, e.g. Europe/Istanbul versus Asia/Istanbul.
 		src = $2
 		dst = $3
 		while ((i = index(src, "/"))) src = substr(src, i+1)
 		while ((i = index(dst, "/"))) dst = substr(dst, i+1)
 		if (src != dst) tz = $3
+	}
 	if (tz && tz ~ /\//) {
-		if (!tz2cc[tz]) {
+		if (!tztab[tz]) {
 			printf "%s: no data for `%s'\n", zone_table, tz \
 				>>"/dev/stderr"
 			status = 1
+		}
 		zoneSeen[tz] = 1
+	}
+}
 END {
 	for (tz in tz2cc) {
 		if (!zoneSeen[tz]) {
 			printf "%s:%d: no Zone table for `%s'\n", \
 				zone_table, tz2NR[tz], tz >>"/dev/stderr"

--- src/lib/libc/time/ctime.3 2013/01/19 11:56:17	1.47
+++ src/lib/libc/time/ctime.3 2013/09/20 19:06:54	1.48

 @@ -1,18 +1,18 @@
-.\" $NetBSD: ctime.3,v 1.47 2013/01/19 11:56:17 apb Exp $
+.\" $NetBSD: ctime.3,v 1.48 2013/09/20 19:06:54 christos Exp $
 .\"
 .\" XXX: License missing?
 .\"
-.Dd January 19, 2013
+.Dd September 20, 2013
 .Dt CTIME 3
 .Os
 .Sh NAME
 .Nm asctime ,
 .Nm asctime_r ,
 .Nm ctime ,
 .Nm ctime_r ,
 .Nm ctime_rz ,
 .Nm difftime ,
 .Nm gmtime ,
 .Nm gmtime_r ,
 .Nm localtime ,
 .Nm localtime_r ,
 @@ -86,38 +86,48 @@ The
 .Fn asctime_r
 has the same behavior as
 .Fn asctime ,
 but the result is stored to
 .Fa buf ,
 which should have a size of at least 26 bytes.
 .It Fn ctime "clock"
 The
 .Fn ctime
 function converts a
 .Vt time_t ,
 pointed to by
 .Fa clock ,
 representing the time in seconds since 00:00:00 UTC, 1970-01-01,
 and returns a pointer to a string with the format described above.
 Years requiring fewer than four characters are padded with leading zeroes.
 For years longer than four characters, the string is of the form
 .Bd -literal -offset indent
 .D1 "Thu Nov 24 18:22:48     81986\en\e0"
 .Ed
 .Pp
 with five spaces before the year.
 These unusual formats are designed to make it less likely that older
 software that expects exactly 26 bytes of output will mistakenly output
 misleading values for out-of-range years.
 .Pp
 The
 .Fa clock
 time stamp represents the time in seconds since 1970-01-01 00:00:00
 Coordinated Universal Time (UTC).
 The POSIX standard says that time stamps must be nonnegative
 and must ignore leap seconds.
 Many implementations extend POSIX by allowing negative time stamps,
 and can therefore represent time stamps that predate the
 introduction of UTC and are some other flavor of Universal Time (UT).
 Some implementations support leap seconds, in contradiction to POSIX.
 .It Fn ctime_r "clock" "buf"
 The
 .Fn ctime_r
 is similar to
 .Fn ctime ,
 except it places the result of the conversion on the
 .Fa buf
 argument, which should be 26 or more bytes long,
 instead of using a global static buffer.
 .It Fn ctime_rz "tz" "clock" "buf"
 The
 .Fn ctime_rz
 function is similar to
 @@ -319,26 +329,68 @@ returns the name for the given
 If
 .Fa isdst
 is
 .Va 0 ,
 the call is equivalent to
 .Va tzname[0] .
 If
 .Fa isdst
 is set to
 .Va 1
 the call is equivalent to
 .Va tzname[1] .
 .El
 .Pp
 Declarations of all the functions and externals, and the
 .Ft tm
 structure, are in the
 .In time.h
 header file.
 The structure (of type)
 .Ft struct tm
 includes the following fields:
 .Bd -literal
        int tm_sec;      /* seconds (0 - 60) */
        int tm_min;      /* minutes (0 - 59) */
        int tm_hour;     /* hours (0 - 23) */
        int tm_mday;     /* day of month (1 - 31) */
        int tm_mon;      /* month of year (0 - 11) */
        int tm_year;     /* year - 1900 */
        int tm_wday;     /* day of week (Sunday = 0) */
        int tm_yday;     /* day of year (0 - 365) */
        int tm_isdst;    /* is summer time in effect? */
        char *tm_zone;   /* abbreviation of timezone name */
        long tm_gmtoff;  /* offset from UT in seconds */
 .Ed
 .Pp
 The
 .Fa tm_zone
 and
 .Fa tm_gmtoff
 fields exist, and are filled in, only if
 arrangements to do so were made when the library containing these functions
 was created.
 There is no guarantee that these fields  will  continue to exist in this form
 in future releases of this code.
 .Bl -bullet
 .It
 .Va tm_isdst
 is non-zero if summer time is in effect.
 .It
 .Va tm_gmtoff
 is the offset (in seconds) of the time represented from UT,
 with positive values indicating east of the Prime Meridian.
 The field's name is derived from Greenwich Mean Time, a precursor of UT.
 .El
 .Sh RETURN VALUES
 .Bl -bullet
 .It
 On success the
 .Fn asctime
 and
 .Fn ctime
 functions return a pointer to a static character buffer, and the
 .Fn asctime_r ,
 .Fn ctime_r ,
 and
 .Fn ctime_rz
 function return a pointer to the user-supplied buffer.

--- src/lib/libc/time/localtime.c 2013/07/30 15:30:37	1.77
+++ src/lib/libc/time/localtime.c 2013/09/20 19:06:54	1.78

 @@ -1,49 +1,48 @@
-/*	$NetBSD: localtime.c,v 1.77 2013/07/30 15:30:37 joerg Exp $	*/
+/*	$NetBSD: localtime.c,v 1.78 2013/09/20 19:06:54 christos Exp $	*/
 /*
 ** This file is in the public domain, so clarified as of
 ** 1996-06-05 by Arthur David Olson.
 */
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
 #if 0
 static char	elsieid[] = "@(#)localtime.c	8.17";
 #else
-__RCSID("$NetBSD: localtime.c,v 1.77 2013/07/30 15:30:37 joerg Exp $");
+__RCSID("$NetBSD: localtime.c,v 1.78 2013/09/20 19:06:54 christos Exp $");
 #endif
 #endif /* LIBC_SCCS and not lint */
 /*
 ** Leap second handling from Bradley White.
 ** POSIX-style TZ environment variable handling from Guy Harris.
 */
 /*LINTLIBRARY*/
 #include "namespace.h"
 #include <assert.h>
 #include "private.h"
 #include "tzfile.h"
 #include "fcntl.h"
 #include "reentrant.h"
 #if defined(__weak_alias)
 __weak_alias(daylight,_daylight)
 __weak_alias(tzname,_tzname)
 #endif
 #include "float.h"	/* for FLT_MAX and DBL_MAX */
 #ifndef TZ_ABBR_MAX_LEN
 #define TZ_ABBR_MAX_LEN	16
 #endif /* !defined TZ_ABBR_MAX_LEN */
 #ifndef TZ_ABBR_CHAR_SET
 #define TZ_ABBR_CHAR_SET \
 	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._"
 #endif /* !defined TZ_ABBR_CHAR_SET */
 #ifndef TZ_ABBR_ERR_CHAR
 #define TZ_ABBR_ERR_CHAR	'_'
 #endif /* !defined TZ_ABBR_ERR_CHAR */
 @@ -87,31 +86,31 @@ static const char	gmt[] = "GMT";
 /*
 ** The DST rules to use if TZ has no rules and we can't load TZDEFRULES.
 ** We default to US rules as of 1999-08-17.
 ** POSIX 1003.1 section 8.1.1 says that the default DST rules are
 ** implementation dependent; for historical reasons, US rules are a
 ** common default.
 */
 #ifndef TZDEFRULESTRING
 #define TZDEFRULESTRING ",M4.1.0,M10.5.0"
 #endif /* !defined TZDEFDST */
 struct ttinfo {				/* time type information */
-	int_fast32_t	tt_gmtoff;	/* UTC offset in seconds */
+	int_fast32_t	tt_gmtoff;	/* UT offset in seconds */
 	int		tt_isdst;	/* used to set tm_isdst */
 	int		tt_abbrind;	/* abbreviation list index */
 	int		tt_ttisstd;	/* TRUE if transition is std time */
-	int		tt_ttisgmt;	/* TRUE if transition is UTC */
+	int		tt_ttisgmt;	/* TRUE if transition is UT */
 };
 struct lsinfo {				/* leap second information */
 	time_t		ls_trans;	/* transition time */
 	int_fast64_t	ls_corr;	/* correction to apply */
 };
 #define BIGGEST(a, b)	(((a) > (b)) ? (a) : (b))
 #ifdef TZNAME_MAX
 #define MY_TZNAME_MAX	TZNAME_MAX
 #endif /* defined TZNAME_MAX */
 #ifndef TZNAME_MAX
 @@ -347,29 +346,28 @@ settzname(void)
 			timezone = -(ttisp->tt_gmtoff);
 #endif /* defined USG_COMPAT */
 #ifdef ALTZONE
 		if (ttisp->tt_isdst)
 			altzone = -(ttisp->tt_gmtoff);
 #endif /* defined ALTZONE */
+	}
 	settzname_z(sp);
+}
 static int
 differ_by_repeat(const time_t t1, const time_t t0)
+{
-	if (TYPE_INTEGRAL(time_t) &&
+	if (TYPE_BIT(time_t) - TYPE_SIGNED(time_t) < SECSPERREPEAT_BITS)
-		TYPE_BIT(time_t) - TYPE_SIGNED(time_t) < SECSPERREPEAT_BITS)
+		return 0;
 			return 0;
 	return (int_fast64_t)t1 - (int_fast64_t)t0 == SECSPERREPEAT;
+}
 static int
 tzload(timezone_t sp, const char *name, const int doextend)
+{
 	const char *		p;
 	int			i;
 	int			fid;
 	int			stored;
 	ssize_t			nread;
 	typedef union {
 		struct tzhead	tzhead;
 @@ -556,31 +554,29 @@ tzload(timezone_t sp, const char *name,
 					sp->timecnt = j;
+				}
 				break;
+			}
 		/*
 		** If this is an old file, we're done.
 		*/
 		if (up->tzhead.tzh_version[0] == '\0')
 			break;
 		nread -= p - up->buf;
 		for (i = 0; i < nread; ++i)
 			up->buf[i] = p[i];
 		/*
-		** If this is a narrow integer time_t system, we're done.
+		** If this is a narrow time_t system, we're done.
 		*/
-		if (stored >= (int) sizeof(time_t)
+		if (stored >= (int) sizeof(time_t))
 /* CONSTCOND */
 				&& TYPE_INTEGRAL(time_t))
 			break;
+	}
 	if (doextend && nread > 2 &&
 		up->buf[0] == '\n' && up->buf[nread - 1] == '\n' &&
 		sp->typecnt + 2 <= TZ_MAX_TYPES) {
 			struct __state ts;
 			int	result;
 			up->buf[nread - 1] = '\0';
 			result = tzparse(&ts, &up->buf[1], FALSE);
 			if (result == 0 && ts.typecnt == 2 &&
 				sp->charcnt + ts.charcnt <= TZ_MAX_CHARS) {
 					for (i = 0; i < 2; ++i)
 @@ -870,34 +866,34 @@ getrule(const char *strp, struct rule *c
 		/*
 		** Day of year.
 		*/
 		rulep->r_type = DAY_OF_YEAR;
 		strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
 	} else	return NULL;		/* invalid format */
 	if (strp == NULL)
 		return NULL;
 	if (*strp == '/') {
 		/*
 		** Time specified.
 		*/
 		++strp;
-		strp = getsecs(strp, &rulep->r_time);
+		strp = getoffset(strp, &rulep->r_time);
 	} else	rulep->r_time = 2 * SECSPERHOUR;	/* default = 2:00:00 */
 	return strp;
+}
 /*
 ** Given the Epoch-relative time of January 1, 00:00:00 UTC, in a year, the
-** year, a rule, and the offset from UTC at the time that rule takes effect,
+** year, a rule, and the offset from UT at the time that rule takes effect,
 ** calculate the Epoch-relative time that rule takes effect.
 */
 static time_t
 transtime(const time_t janfirst, const int year, const struct rule *const rulep,
     const int_fast32_t offset)
+{
 	int	leapyear;
 	time_t	value;
 	int	i;
 	int		d, m1, yy0, yy1, yy2, dow;
 	INITIALIZE(value);
 @@ -960,30 +956,30 @@ transtime(const time_t janfirst, const i
 				mon_lengths[leapyear][rulep->r_mon - 1])
 					break;
 			d += DAYSPERWEEK;
+		}
 		/*
 		** "d" is the day-of-month (zero-origin) of the day we want.
 		*/
 		value += (time_t)(d * SECSPERDAY);
 		break;
+	}
 	/*
-	** "value" is the Epoch-relative time of 00:00:00 UTC on the day in
+	** "value" is the Epoch-relative time of 00:00:00 UT on the day in
 	** question. To get the Epoch-relative time of the specified local
 	** time on that day, add the transition time and the current offset
-	** from UTC.
+	** from UT.
 	*/
 	return (time_t)(value + rulep->r_time + offset);
+}
 /*
 ** Given a POSIX section 8-style TZ string, fill in the rule tables as
 ** appropriate.
 */
 static int
 tzparse(timezone_t sp, const char *name, const int lastditch)
+{
 	const char *		stdname;
 @@ -1040,28 +1036,29 @@ tzparse(timezone_t sp, const char *name,
 			name = getzname(name);
 			dstlen = name - dstname; /* length of DST zone name */
+		}
 		if (*name != '\0' && *name != ',' && *name != ';') {
 			name = getoffset(name, &dstoffset);
 			if (name == NULL)
 				return -1;
 		} else	dstoffset = stdoffset - SECSPERHOUR;
 		if (*name == '\0' && load_result != 0)
 			name = TZDEFRULESTRING;
 		if (*name == ',' || *name == ';') {
 			struct rule	start;
 			struct rule	end;
-			int	year;
+			int		year;
-			time_t	janfirst;
+			int		yearlim;
 			time_t		janfirst;
 			time_t		starttime;
 			time_t		endtime;
 			++name;
 			if ((name = getrule(name, &start)) == NULL)
 				return -1;
 			if (*name++ != ',')
 				return -1;
 			if ((name = getrule(name, &end)) == NULL)
 				return -1;
 			if (*name != '\0')
 				return -1;
 			sp->typecnt = 2;	/* standard time and DST */
 @@ -1069,54 +1066,64 @@ tzparse(timezone_t sp, const char *name,
 			** Two transitions per year, from EPOCH_YEAR forward.
 			*/
 			memset(sp->ttis, 0, sizeof(sp->ttis));
 			sp->ttis[0].tt_gmtoff = -dstoffset;
 			sp->ttis[0].tt_isdst = 1;
 			sp->ttis[0].tt_abbrind = (int)(stdlen + 1);
 			sp->ttis[1].tt_gmtoff = -stdoffset;
 			sp->ttis[1].tt_isdst = 0;
 			sp->ttis[1].tt_abbrind = 0;
 			atp = sp->ats;
 			typep = sp->types;
 			janfirst = 0;
 			sp->timecnt = 0;
-			for (year = EPOCH_YEAR;
+			yearlim = EPOCH_YEAR + YEARSPERREPEAT;
-			    sp->timecnt + 2 <= TZ_MAX_TIMES;
+			for (year = EPOCH_YEAR; year < yearlim; year++) {
-			    ++year) {
+				int_fast32_t yearsecs;
 			    	time_t	newfirst;
 				starttime = transtime(janfirst, year, &start,
 					stdoffset);
 				endtime = transtime(janfirst, year, &end,
 					dstoffset);
-				if (starttime > endtime) {
+				yearsecs = (year_lengths[isleap(year)]
-					*atp++ = endtime;
+					    * SECSPERDAY);
-					*typep++ = 1;	/* DST ends */
+				if (starttime > endtime
-					*atp++ = starttime;
+				    || (starttime < endtime
-					*typep++ = 0;	/* DST begins */
+					&& (endtime - starttime
-				} else {
+					    < (yearsecs
-					*atp++ = starttime;
+					       + (stdoffset - dstoffset))))) {
-					*typep++ = 0;	/* DST begins */
+					if (&sp->ats[TZ_MAX_TIMES - 2] < atp)
-					*atp++ = endtime;
+						break;
-					*typep++ = 1;	/* DST ends */
+					yearlim = year + YEARSPERREPEAT + 1;
 					if (starttime > endtime) {
 						*atp++ = endtime;
 						*typep++ = 1;	/* DST ends */
 						*atp++ = starttime;
 						*typep++ = 0;	/* DST begins */
 					} else {
 						*atp++ = starttime;
 						*typep++ = 0;	/* DST begins */
 						*atp++ = endtime;
 						*typep++ = 1;	/* DST ends */
+					}
+				}
-				sp->timecnt += 2;
+				if (time_t_max - janfirst < yearsecs)
 				newfirst = janfirst;
 				newfirst += (time_t)
 				    (year_lengths[isleap(year)] * SECSPERDAY);
 				if (newfirst <= janfirst)
 					break;
-				janfirst = newfirst;
+				janfirst += yearsecs;
+			}
 			_DIAGASSERT(__type_fit(int, atp - sp->ats));
 			sp->timecnt = (int)(atp - sp->ats);
 			if (!sp->timecnt)
 				sp->typecnt = 1;	/* Perpetual DST.  */
 		} else {
 			int_fast32_t	theirstdoffset;
 			int_fast32_t	theirdstoffset;
 			int_fast32_t	theiroffset;
 			int		isdst;
 			int		i;
 			int		j;
 			if (*name != '\0')
 				return -1;
 			/*
 			** Initial values of theirstdoffset and theirdstoffset.
 			*/
 @@ -1352,56 +1359,48 @@ tzset(void)
 static struct tm *
 localsub(const timezone_t sp, const time_t * const timep, const int_fast32_t offset,
     struct tm *const tmp)
+{
 	const struct ttinfo *	ttisp;
 	int			i;
 	struct tm *		result;
 	const time_t			t = *timep;
 	if ((sp->goback && t < sp->ats[0]) ||
 		(sp->goahead && t > sp->ats[sp->timecnt - 1])) {
 			time_t			newt = t;
 			time_t		seconds;
-			time_t		tcycles;
+			time_t		years;
 			int_fast64_t	icycles;
 			if (t < sp->ats[0])
 				seconds = sp->ats[0] - t;
 			else	seconds = t - sp->ats[sp->timecnt - 1];
 			--seconds;
-			tcycles = (time_t)
+			years = (time_t)((seconds / SECSPERREPEAT + 1) * YEARSPERREPEAT);
-			    (seconds / YEARSPERREPEAT / AVGSECSPERYEAR);
+			seconds = (time_t)(years * AVGSECSPERYEAR);
 			++tcycles;
 			icycles = tcycles;
 			if (tcycles - icycles >= 1 || icycles - tcycles >= 1)
 				return NULL;
 			seconds = (time_t) icycles;
 			seconds *= YEARSPERREPEAT;
 			seconds *= AVGSECSPERYEAR;
 			if (t < sp->ats[0])
 				newt += seconds;
 			else	newt -= seconds;
 			if (newt < sp->ats[0] ||
 				newt > sp->ats[sp->timecnt - 1])
 					return NULL;	/* "cannot happen" */
 			result = localsub(sp, &newt, offset, tmp);
 			if (result == tmp) {
 				time_t	newy;
 				newy = tmp->tm_year;
 				if (t < sp->ats[0])
-					newy -= (time_t)icycles * YEARSPERREPEAT;
+					newy -= years;
-				else	newy += (time_t)icycles * YEARSPERREPEAT;
+				else	newy += years;
 				tmp->tm_year = (int)newy;
 				if (tmp->tm_year != newy)
 					return NULL;
+			}
 			return result;
+	}
 	if (sp->timecnt == 0 || t < sp->ats[0]) {
 		i = sp->defaulttype;
 	} else {
 		int	lo = 1;
 		int	hi = sp->timecnt;
 		while (lo < hi) {
 @@ -1480,27 +1479,27 @@ gmtsub(const timezone_t sp, const time_t
 		int saveerrno;
 		gmt_is_set = TRUE;
 		saveerrno = errno;
 		gmtptr = calloc(1, sizeof *gmtptr);
 		errno = saveerrno;
 		if (gmtptr != NULL)
 			gmtload(gmtptr);
+	}
 	mutex_unlock(&gmt_mutex);
 	result = timesub(gmtptr, timep, offset, tmp);
 #ifdef TM_ZONE
 	/*
 	** Could get fancy here and deliver something such as
-	** "UTC+xxxx" or "UTC-xxxx" if offset is non-zero,
+	** "UT+xxxx" or "UT-xxxx" if offset is non-zero,
 	** but this is no time for a treasure hunt.
 	*/
 	if (offset != 0)
 		tmp->TM_ZONE = (__aconst char *)__UNCONST(wildabbr);
 	else {
 		if (gmtptr == NULL)
 			tmp->TM_ZONE = (__aconst char *)__UNCONST(gmt);
 		else	tmp->TM_ZONE = gmtptr->chars;
+	}
 #endif /* defined TM_ZONE */
 	return result;
+}
 @@ -1617,45 +1616,45 @@ timesub(const timezone_t sp, const time_
 			break;
+		}
+	}
 	y = EPOCH_YEAR;
 	tdays = (time_t)(*timep / SECSPERDAY);
 	rem = (int_fast64_t) (*timep - tdays * SECSPERDAY);
 	while (tdays < 0 || tdays >= year_lengths[isleap(y)]) {
 		int		newy;
 		time_t	tdelta;
 		int	idelta;
 		int	leapdays;
 		tdelta = tdays / DAYSPERLYEAR;
-		idelta = (int) tdelta;
+		if (! ((! TYPE_SIGNED(time_t) || INT_MIN <= tdelta)
-		if (tdelta - idelta >= 1 || idelta - tdelta >= 1)
+		       && tdelta <= INT_MAX))
 			return NULL;
 		idelta = tdelta;
 		if (idelta == 0)
 			idelta = (tdays < 0) ? -1 : 1;
 		newy = y;
 		if (increment_overflow(&newy, idelta))
 			return NULL;
 		leapdays = leaps_thru_end_of(newy - 1) -
 			leaps_thru_end_of(y - 1);
 		tdays -= ((time_t) newy - y) * DAYSPERNYEAR;
 		tdays -= leapdays;
 		y = newy;
+	}
+	{
 		int_fast32_t seconds;
 		const time_t half_second = (time_t)0.5;
-		seconds = (int_fast32_t)(tdays * SECSPERDAY + half_second);
+		seconds = (int_fast32_t)(tdays * SECSPERDAY);
 		tdays = (time_t)(seconds / SECSPERDAY);
 		rem += (int_fast64_t)(seconds - tdays * SECSPERDAY);
+	}
 	/*
 	** Given the range, we can now fearlessly cast...
 	*/
 	idays = (int) tdays;
 	rem += offset - corr;
 	while (rem < 0) {
 		rem += SECSPERDAY;
 		--idays;
+	}
 	while (rem >= SECSPERDAY) {
 @@ -1809,28 +1808,29 @@ normalize_overflow32(int_fast32_t *const
 	tensdelta = (*unitsptr >= 0) ?
 		(*unitsptr / base) :
 		(-1 - (-1 - *unitsptr) / base);
 	*unitsptr -= tensdelta * base;
 	return increment_overflow32(tensptr, tensdelta);
+}
 static int
 tmcomp(const struct tm *const atmp, const struct tm *const btmp)
+{
 	int	result;
-	if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
+	if (atmp->tm_year != btmp->tm_year)
-		(result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
+		return atmp->tm_year < btmp->tm_year ? -1 : 1;
 	if ((result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
 		(result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
 		(result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
 		(result = (atmp->tm_min - btmp->tm_min)) == 0)
 			result = atmp->tm_sec - btmp->tm_sec;
 	return result;
+}
 static time_t
 time2sub(const timezone_t sp, struct tm *const tmp, subfun_t funcp,
     const int_fast32_t offset, int *const okayp, const int do_norm_secs)
+{
 	int			dir;
 	int			i, j;
 @@ -1913,68 +1913,59 @@ again:
 		saved_seconds = yourtm.tm_sec;
 		yourtm.tm_sec = SECSPERMIN - 1;
 	} else {
 		saved_seconds = yourtm.tm_sec;
 		yourtm.tm_sec = 0;
+	}
 	/*
 	** Do a binary search (this works whatever time_t's type is).
 	*/
 	/* LINTED const not */
 	if (!TYPE_SIGNED(time_t)) {
 		lo = 0;
 		hi = lo - 1;
 	/* LINTED const not */
 	} else if (!TYPE_INTEGRAL(time_t)) {
 		/* CONSTCOND */
 		if (sizeof(time_t) > sizeof(float))
 			/* LINTED assumed double */
 			hi = (time_t) DBL_MAX;
 			/* LINTED assumed float */
 		else	hi = (time_t) FLT_MAX;
 		lo = -hi;
 	} else {
 		lo = 1;
 		for (i = 0; i < (int) TYPE_BIT(time_t) - 1; ++i)
 			lo *= 2;
 		hi = -(lo + 1);
+	}
 #ifdef NO_ERROR_IN_DST_GAP
 	ilo = lo;
 #endif
 	for ( ; ; ) {
 		t = lo / 2 + hi / 2;
 		if (t < lo)
 			t = lo;
 		else if (t > hi)
 			t = hi;
 		if ((*funcp)(sp, &t, offset, &mytm) == NULL) {
 			/*
 			** Assume that t is too extreme to be represented in
 			** a struct tm; arrange things so that it is less
 			** extreme on the next pass.
 			*/
 			dir = (t > 0) ? 1 : -1;
 		} else	dir = tmcomp(&mytm, &yourtm);
 		if (dir != 0) {
 			if (t == lo) {
-				++t;
+				if (t == time_t_max)
 				if (t <= lo)
 					goto overflow;
 				++t;
 				++lo;
 			} else if (t == hi) {
-				--t;
+				if (t == time_t_min)
 				if (t >= hi)
 					goto overflow;
 				--t;
 				--hi;
+			}
 #ifdef NO_ERROR_IN_DST_GAP
 			if (ilo != lo && lo - 1 == hi && yourtm.tm_isdst < 0 &&
 			    do_norm_secs) {
 				for (i = sp->typecnt - 1; i >= 0; --i) {
 					for (j = sp->typecnt - 1; j >= 0; --j) {
 						time_t off;
 						if (sp->ttis[j].tt_isdst ==
 						    sp->ttis[i].tt_isdst)
 							continue;
 						off = sp->ttis[j].tt_gmtoff -
 						    sp->ttis[i].tt_gmtoff;
 @@ -2198,27 +2189,27 @@ timeoff(struct tm *const tmp, long offse
 	t = time1(gmtptr, tmp, gmtsub, (int_fast32_t)offset);
 	return t;
+}
 #endif /* defined STD_INSPIRED */
 #ifdef CMUCS
 /*
 ** The following is supplied for compatibility with
 ** previous versions of the CMUCS runtime library.
 */
-int_fast32_t
+long
 gtime(struct tm *const tmp)
+{
 	const time_t t = mktime(tmp);
 	if (t == WRONG)
 		return -1;
 	return t;
+}
 #endif /* defined CMUCS */
 /*
 ** XXX--is the below the right way to conditionalize??

--- src/lib/libc/time/private.h 2013/07/17 20:13:04	1.29
+++ src/lib/libc/time/private.h 2013/09/20 19:06:54	1.30

 @@ -1,14 +1,14 @@
-/*	$NetBSD: private.h,v 1.29 2013/07/17 20:13:04 christos Exp $	*/
+/*	$NetBSD: private.h,v 1.30 2013/09/20 19:06:54 christos Exp $	*/
 #ifndef PRIVATE_H
 #define PRIVATE_H
 /* NetBSD defaults */
 #define TM_GMTOFF	tm_gmtoff
 #define TM_ZONE		tm_zone
 #define STD_INSPIRED	1
 #define HAVE_LONG_DOUBLE 1
 /* For when we build zic as a host tool. */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 @@ -168,56 +168,69 @@ typedef long		int_fast64_t;
 #endif /* !defined INT_FAST64_MAX */
 #ifndef INT_FAST32_MAX
 # if INT_MAX >> 31 == 0
 typedef long int_fast32_t;
 # else
 typedef int int_fast32_t;
 # endif
 #endif
 #ifndef INTMAX_MAX
 # if defined LLONG_MAX || defined __LONG_LONG_MAX__
 typedef long long intmax_t;
 #  define strtoimax strtoll
 #  define PRIdMAX "lld"
 #  ifdef LLONG_MAX
 #   define INTMAX_MAX LLONG_MAX
 #   define INTMAX_MIN LLONG_MIN
 #  else
 #   define INTMAX_MAX __LONG_LONG_MAX__
 #   define INTMAX_MIN __LONG_LONG_MIN__
 #  endif
 # else
 typedef long intmax_t;
 #  define strtoimax strtol
 #  define PRIdMAX "ld"
 #  define INTMAX_MAX LONG_MAX
 #  define INTMAX_MIN LONG_MIN
 # endif
 #endif
 #ifndef UINTMAX_MAX
 # if defined ULLONG_MAX || defined __LONG_LONG_MAX__
 typedef unsigned long long uintmax_t;
 #  define PRIuMAX "llu"
 # else
 typedef unsigned long uintmax_t;
 #  define PRIuMAX "lu"
 # endif
 #endif
 #ifndef INT32_MAX
 #define INT32_MAX 0x7fffffff
 #endif /* !defined INT32_MAX */
 #ifndef INT32_MIN
 #define INT32_MIN (-1 - INT32_MAX)
 #endif /* !defined INT32_MIN */
 #if 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
 # define ATTRIBUTE_CONST __attribute__ ((__const__))
 # define ATTRIBUTE_PURE __attribute__ ((__pure__))
 # define ATTRIBUTE_FORMAT(spec) __attribute__ ((__format__ spec))
 #else
 # define ATTRIBUTE_CONST /* empty */
 # define ATTRIBUTE_PURE /* empty */
 # define ATTRIBUTE_FORMAT(spec) /* empty */
 #endif
 #if !defined _Noreturn && __STDC_VERSION__ < 201112
 # if 2 < __GNUC__ + (8 <= __GNUC_MINOR__)
 #  define _Noreturn __attribute__ ((__noreturn__))
 # else
 #  define _Noreturn
 # endif
 #endif
 #if __STDC_VERSION__ < 199901 && !defined restrict
 # define restrict /* empty */
 #endif
 @@ -306,34 +319,36 @@ const char *	scheck(const char * string,
 #ifndef FALSE
 #define FALSE	0
 #endif /* !defined FALSE */
 #ifndef TYPE_BIT
 #define TYPE_BIT(type)	(sizeof (type) * CHAR_BIT)
 #endif /* !defined TYPE_BIT */
 #ifndef TYPE_SIGNED
 #define TYPE_SIGNED(type) (/*CONSTCOND*/((type) -1) < 0)
 #endif /* !defined TYPE_SIGNED */
-/*
+/* The minimum and maximum finite time values.  */
-** Since the definition of TYPE_INTEGRAL contains floating point numbers,
+static time_t const time_t_min =
-** it cannot be used in preprocessor directives.
+  (TYPE_SIGNED(time_t)
-*/
+   ? (time_t) -1 << (int)(CHAR_BIT * sizeof (time_t) - 1)
 /*###336 [lint] warning semantics of 'p << p' change in ANSI C; use explicit cast [118]%%%*/
-#ifndef TYPE_INTEGRAL
+   : 0);
-#define TYPE_INTEGRAL(type) (/*CONSTCOND*/((type) 0.5) != 0.5)
+static time_t const time_t_max =
-#endif /* !defined TYPE_INTEGRAL */
+  (TYPE_SIGNED(time_t)
    ? - (~ 0 < 0) - ((time_t) -1 << (int)(CHAR_BIT * sizeof (time_t) - 1))
    : -1);
 #ifndef INT_STRLEN_MAXIMUM
 /*
 ** 302 / 1000 is log10(2.0) rounded up.
 ** Subtract one for the sign bit if the type is signed;
 ** add one for integer division truncation;
 ** add one more for a minus sign if the type is signed.
 */
 #define INT_STRLEN_MAXIMUM(type) \
 	((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + \
 + TYPE_SIGNED(type))
 #endif /* !defined INT_STRLEN_MAXIMUM */

--- src/lib/libc/time/strftime.3 2012/04/06 11:35:39	1.29
+++ src/lib/libc/time/strftime.3 2013/09/20 19:06:54	1.30

 @@ -20,27 +20,27 @@
 .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 .\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
 .\"     from: @(#)strftime.3	5.12 (Berkeley) 6/29/91
-.\"	$NetBSD: strftime.3,v 1.29 2012/04/06 11:35:39 wiz Exp $
+.\"	$NetBSD: strftime.3,v 1.30 2013/09/20 19:06:54 christos Exp $
 .\"
 .Dd April 14, 2011
 .Dt STRFTIME 3
 .Os
 .Sh NAME
 .Nm strftime ,
 .Nm strftime_z
 .Nd format date and time
 .Sh LIBRARY
 .Lb libc
 .Sh SYNOPSIS
 .In time.h
 .Ft size_t
 @@ -139,28 +139,28 @@ or
 .Dq Tn PM .
 .It Cm \&%R
 is replaced by the time in the format
 .Dq Li %H:%M .
 .It Cm \&%r
 is replaced by the locale's representation of 12-hour clock time
 using AM/PM notation.
 .It Cm \&%S
 is replaced by the second as a decimal number [00,61].
 The range of
 seconds is (00-61) instead of (00-59) to allow for the periodic occurrence
 of leap seconds and double leap seconds.
 .It Cm %s
-is replaced by the number of seconds since the Epoch, UTC (see
+is replaced by the number of seconds since the Epoch (see
-.Xr mktime 3 ) .
+.Xr ctime 3 ) .
 .It Cm \&%T
 is replaced by the time in the format
 .Dq Li %H:%M:%S .
 .It Cm \&%t
 is replaced by a tab.
 .It Cm \&%U
 is replaced by the week number of the year (Sunday as the first day of
 the week) as a decimal number [00,53].
 .It Cm \&%u
 is replaced by the weekday (Monday as the first day of the week)
 as a decimal number [1,7].
 .It Cm \&%V
 is replaced by the week number of the year (Monday as the first day of
 @@ -180,27 +180,30 @@ the week) as a decimal number [00,53].
 is replaced by the weekday (Sunday as the first day of the week)
 as a decimal number [0,6].
 .It Cm \&%X
 is replaced by the locale's appropriate time representation.
 .It Cm \&%x
 is replaced by the locale's appropriate date representation.
 .It Cm \&%Y
 is replaced by the year with century as a decimal number.
 .It Cm \&%y
 is replaced by the year without century as a decimal number [00,99].
 .It Cm \&%Z
 is replaced by the time zone name.
 .It Cm \&%z
-is replaced by the offset from UTC in the ISO 8601 format
+is replaced by the offset from the Prime Meridian in the format
 +HHMM or -HHMM (ISO 8601) as appropriate, with positive values representing
 locations east of Greenwich, or by the empty string if this is
 not determinable.
 .Dq Li [-]hhmm .
 .It Cm %%
 is replaced by
 .Ql % .
 .El
 .Pp
 The
 .Fn strftime_z
 function is similar to
 .Fn strftime ,
 but it also takes a
 .Ft "const timezone_t"
 .Fa tz

--- src/lib/libc/time/strftime.c 2013/07/17 23:09:26	1.28
+++ src/lib/libc/time/strftime.c 2013/09/20 19:06:54	1.29

 @@ -1,22 +1,22 @@
-/*	$NetBSD: strftime.c,v 1.28 2013/07/17 23:09:26 christos Exp $	*/
+/*	$NetBSD: strftime.c,v 1.29 2013/09/20 19:06:54 christos Exp $	*/
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
 #if 0
 static char	elsieid[] = "@(#)strftime.c	7.64";
 static char	elsieid[] = "@(#)strftime.c	8.3";
 #else
-__RCSID("$NetBSD: strftime.c,v 1.28 2013/07/17 23:09:26 christos Exp $");
+__RCSID("$NetBSD: strftime.c,v 1.29 2013/09/20 19:06:54 christos Exp $");
 #endif
 #endif /* LIBC_SCCS and not lint */
 #include "namespace.h"
 #include <stddef.h>
 #include <locale.h>
 #include "setlocale_local.h"
 /*
 ** Based on the UCB version with the copyright notice and sccsid
 ** appearing below.
 **
 @@ -494,27 +494,27 @@ label:
 				*/
 				continue;
 			case 'z':
+				{
 				int		diff;
 				char const *	sign;
 				if (t->tm_isdst < 0)
 					continue;
 #ifdef TM_GMTOFF
 				diff = (int)t->TM_GMTOFF;
 #else /* !defined TM_GMTOFF */
 				/*
-				** C99 says that the UTC offset must
+				** C99 says that the UT offset must
 				** be computed by looking only at
 				** tm_isdst. This requirement is
 				** incorrect, since it means the code
 				** must rely on magic (in this case
 				** altzone and timezone), and the
 				** magic might not have the correct
 				** offset. Doing things correctly is
 				** tricky and requires disobeying C99;
 				** see GNU C strftime for details.
 				** For now, punt and conform to the
 				** standard, even though it's incorrect.
 				**
 				** C99 says that %z must be replaced by the

--- src/lib/libc/time/Attic/tz-link.htm 2013/07/17 20:13:04	1.11
+++ src/lib/libc/time/Attic/tz-link.htm 2013/09/20 19:06:54	1.12

 @@ -1,24 +1,24 @@
 <!DOCTYPE html
 	PUBLIC "-//W3C//DTD HTML 4.01//EN"
 	"http://www.w3.org/TR/html4/strict.dtd">
 <html>
 <head>
 <title>Sources for Time Zone and Daylight Saving Time Data</title>
 <link rel="schema.DC" href="http://purl.org/DC/elements/1.1/">
 <meta http-equiv="Content-type" content='text/html; charset="US-ASCII"'>
 <meta name="DC.Creator" content="Eggert, Paul">
 <meta name="DC.Contributor" content="Olson, Arthur David">
-<meta name="DC.Date" content="2013-07-03">
+<meta name="DC.Date" content="2013-09-05">
 <meta name="DC.Description"
  content="Sources of information about time zones and daylight saving time">
 <meta name="DC.Identifier"
  content="http://www.iana.org/time-zones/repository/tz-link.htm">
 <meta name="Keywords"
  content="database,daylight saving,DST,time zone,timezone,tz,zoneinfo">
 </head>
 <body>
 <h1>Sources for Time Zone and Daylight Saving Time Data</h1>
 <h2>The <code>tz</code> database</h2>
 <p>
 The <a href="http://en.wikipedia.org/wiki/Public_domain">public-domain</a>
 time zone database contains code and data
 @@ -384,32 +384,35 @@ of the University of Texas at Austin has
 recent editions.
 The pictorial quality is good,
 but the maps do not indicate summer time,
 and parts of the data are a few years out of date.</li>
 <li><a href="http://worldtimezone.com/">Current time around the world
 and standard time zones map of the world</a>
 has several fancy time zone maps; it covers Russia particularly well.
 The maps' pictorial quality is not quite as good as the
 <abbr>CIA</abbr>'s
 but the maps are more up to date.</li>
 </ul>
 <h2>Time zone boundaries</h2>
 <ul>
-<li><a href="http://efele.net/maps/tz/">TZ timezone maps</a> contains a <a
+<li><a href="http://efele.net/maps/tz/">TZ timezones maps</a> contains <a
-href="http://en.wikipedia.org/wiki/Shapefile">shapefile</a> of the
+href="http://en.wikipedia.org/wiki/Shapefile">shapefiles</a> of
-<code>tz</code> regions in the world.</li>
+sets of <code>tz</code> regions.</li>
-<li><a href="http://statoids.com/statoids.html">Administrative Divisions
+<li><a href="http://derickrethans.nl/what-time-is-it.html">What Time
-of Countries ("Statoids")</a> contains detailed lists of
+is It Here?</a> applies <a href="http://www.mongodb.org/">MongoDB</a>
-<code>tz</code>-related zone subdivision data.</li>
+geospatial query operators to shapefiles' data.</li>
 <li><a href="http://statoids.com/statoids.html">Administrative
 Divisions of Countries ("Statoids")</a> contains lists of
 political subdivision data related to time zones.</li>
 <li><a href="http://home.tiscali.nl/~t876506/Multizones.html">Time
 zone boundaries for multizone countries</a> summarizes legal
 boundaries between time zones within countries.</li>
 <li>Manifold.net's <a
 href="http://manifold.net/info/freestuff.shtml">Free Stuff for
 Manifold System Users</a> includes a Manifold-format map of
 world time zone boundaries distributed under the
 <abbr>GPL</abbr>.</li>
 <li>The <abbr>US</abbr> Geological Survey's National Atlas of
 the United States
 publishes the <a href="http://nationalatlas.gov/mld/timeznp.html">Time
 Zones of the United States</a> in the public domain.</li>
 <li>The GeoCommunity lists several commercial sources for <a

--- src/lib/libc/time/Attic/tzfile.h 2013/07/17 20:13:04	1.11
+++ src/lib/libc/time/Attic/tzfile.h 2013/09/20 19:06:54	1.12

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tzfile.h,v 1.11 2013/07/17 20:13:04 christos Exp $	*/
+/*	$NetBSD: tzfile.h,v 1.12 2013/09/20 19:06:54 christos Exp $	*/
 #ifndef TZFILE_H
 #define TZFILE_H
 /*
 ** This file is in the public domain, so clarified as of
 ** 1996-06-05 by Arthur David Olson.
 */
 /*
 ** This header is for use ONLY with the time conversion code.
 ** There is no guarantee that it will remain unchanged,
 ** or that it will remain at all.
 @@ -30,69 +30,76 @@
 #ifndef TZDEFRULES
 #define TZDEFRULES	"posixrules"
 #endif /* !defined TZDEFRULES */
 /*
 ** Each file begins with. . .
 */
 #define	TZ_MAGIC	"TZif"
 struct tzhead {
 	char	tzh_magic[4];		/* TZ_MAGIC */
-	char	tzh_version[1];		/* '\0' or '2' as of 2005 */
+	char	tzh_version[1];		/* '\0' or '2' or '3' as of 2013 */
 	char	tzh_reserved[15];	/* reserved--must be zero */
 	char	tzh_ttisgmtcnt[4];	/* coded number of trans. time flags */
 	char	tzh_ttisstdcnt[4];	/* coded number of trans. time flags */
 	char	tzh_leapcnt[4];		/* coded number of leap seconds */
 	char	tzh_timecnt[4];		/* coded number of transition times */
 	char	tzh_typecnt[4];		/* coded number of local time types */
 	char	tzh_charcnt[4];		/* coded number of abbr. chars */
 };
 /*
 ** . . .followed by. . .
 **
 **	tzh_timecnt (char [4])s		coded transition times a la time(2)
 **	tzh_timecnt (unsigned char)s	types of local time starting at above
 **	tzh_typecnt repetitions of
-**		one (char [4])		coded UTC offset in seconds
+**		one (char [4])		coded UT offset in seconds
 **		one (unsigned char)	used to set tm_isdst
 **		one (unsigned char)	that's an abbreviation list index
 **	tzh_charcnt (char)s		'\0'-terminated zone abbreviations
 **	tzh_leapcnt repetitions of
 **		one (char [4])		coded leap second transition times
 **		one (char [4])		total correction after above
 **	tzh_ttisstdcnt (char)s		indexed by type; if TRUE, transition
 **					time is standard time, if FALSE,
 **					transition time is wall clock time
 **					if absent, transition times are
 **					assumed to be wall clock time
 **	tzh_ttisgmtcnt (char)s		indexed by type; if TRUE, transition
-**					time is UTC, if FALSE,
+**					time is UT, if FALSE,
 **					transition time is local time
 **					if absent, transition times are
 **					assumed to be local time
 */
 /*
 ** If tzh_version is '2' or greater, the above is followed by a second instance
 ** of tzhead and a second instance of the data in which each coded transition
 ** time uses 8 rather than 4 chars,
 ** then a POSIX-TZ-environment-variable-style string for use in handling
 ** instants after the last transition time stored in the file
 ** (with nothing between the newlines if there is no POSIX representation for
 ** such instants).
 **
 ** If tz_version is '3' or greater, the above is extended as follows.
 ** First, the POSIX TZ string's hour offset may range from -167
 ** through 167 as compared to the POSIX-required 0 through 24.
 ** Second, its DST start time may be January 1 at 00:00 and its stop
 ** time December 31 at 24:00 plus the difference between DST and
 ** standard time, indicating DST all year.
 */
 /*
 ** In the current implementation, "tzset()" refuses to deal with files that
 ** exceed any of the limits below.
 */
 #ifndef TZ_MAX_TIMES
 #define TZ_MAX_TIMES	1200
 #endif /* !defined TZ_MAX_TIMES */
 #ifndef TZ_MAX_TYPES
 #ifndef NOSOLAR

--- src/lib/libc/time/tzfile.5 2013/03/02 21:24:28	1.19
+++ src/lib/libc/time/tzfile.5 2013/09/20 19:06:54	1.20

 @@ -1,103 +1,99 @@
-.\"	$NetBSD: tzfile.5,v 1.19 2013/03/02 21:24:28 christos Exp $
+.\"	$NetBSD: tzfile.5,v 1.20 2013/09/20 19:06:54 christos Exp $
 .\"
 .\" This file is in the public domain, so clarified as of
 .\" 1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov).
-.Dd September 16, 2001
+.Dd September 20, 2013
 .Dt TZFILE 5
 .Os
 .Sh NAME
 .Nm tzfile
 .Nd time zone information
 .Sh SYNOPSIS
 .In tzfile.h
 .Sh DESCRIPTION
 The time zone information files used by
 .Xr tzset 3
 begin with the magic characters
 .Dq TZif
 to identify them as time zone information files,
 followed by a character identifying the version of the file's format
-(as of 2005, either an ASCII NUL or a '2')
+(as of 2013, either an ASCII NUL or a '2', or '3')
 followed by fifteen bytes containing zeroes reserved for future use,
 followed by six four-byte values of type
 .Fa long ,
-written in a
+followed by six four-byte integer values written in a
 .Dq standard
 byte order (the high-order byte of the value is written first).
 These values are, in order:
 .Bl -tag -width XXXXXX -compact
 .It Va tzh_ttisgmtcnt
-The number of UTC/local indicators stored in the file.
+The number of UT/local indicators stored in the file.
 .It Va tzh_ttisstdcnt
 The number of standard/wall indicators stored in the file.
 .It Va tzh_leapcnt
 The number of leap seconds for which data is stored in the file.
 .It Va tzh_timecnt
 The number of
 .Dq transition times
 for which data is stored in the file.
 .It Va tzh_typecnt
 The number of
 .Dq local time types
 for which data is stored in the file (must not be zero).
 .It Va tzh_charcnt
 The number of characters of "time zone abbreviation strings"
 stored in the file.
 .El
 .Pp
 The above header is followed by
 .Va tzh_timecnt
-four-byte values of type
+four-byte signed integer values sorted in ascending order.
-.Fa long ,
+These values are written in
 sorted in ascending order.
 These values are written in
 .Dq standard
 byte order.
 Each is used as a transition time (as returned by
 .Xr time 3 )
 at which the rules for computing local time change.
 Next come
 .Va tzh_timecnt
-one-byte values of type
+one-byte unsigned integer values;
 .Fa unsigned char ;
 each one tells which of the different types of
 .Dq local time
 types described in the file is associated with the same-indexed
 transition time.
 These values serve as indices into an array of
 .Fa ttinfo
 structures (with
 .Va tzh_typecnt
 entries) that appears next in the file;
 these structures are defined as follows:
 .Bd -literal
 struct ttinfo {
-	long	tt_gmtoff;
+	int32_t		tt_gmtoff;
-	int	tt_isdst;
+	unsigned char	tt_isdst;
-	unsigned int	tt_abbrind;
+	unsigned char	tt_abbrind;
 };
 .Ed
-Each structure is written as a four-byte value for
+Each structure is written as a four-byte signed integer value for
 .Va tt_gmtoff
 of type
 .Fa long ,
 in a standard byte order, followed by a one-byte value for
 .Va tt_isdst
 and a one-byte value for
 .Va tt_abbrind .
 In each structure,
 .Va tt_gmtoff
-gives the number of seconds to be added to UTC,
+gives the number of seconds to be added to UT,
 .Va tt_isdst
 tells whether
 .Va tm_isdst
 should be set by
 .Xr localtime 3
 and
 .Va tt_abbrind
 serves as an index into the array of time zone abbreviation characters
 that follow the
 .Va ttinfo
 structure(s) in the file.
 .Pp
 Then there are
 @@ -112,48 +108,62 @@ the second gives the
 number of leap seconds to be applied after the given time.
 The pairs of values are sorted in ascending order by time.
 .Pp
 Then there are
 .Va tzh_ttisstdcnt
 standard/wall indicators, each stored as a one-byte value;
 they tell whether the transition times associated with local time types
 were specified as standard time or wall clock time,
 and are used when a time zone file is used in handling POSIX-style
 time zone environment variables.
 .Pp
 Finally there are
 .Va tzh_ttisgmtcnt
-UTC/local indicators, each stored as a one-byte value;
+UT/local indicators, each stored as a one-byte value;
 they tell whether the transition times associated with local time types
-were specified as UTC or local time,
+were specified as UT or local time,
 and are used when a time zone file is used in handling POSIX-style
 time zone environment variables.
 .Pp
 .Xr localtime 3
 uses the first standard-time
 .Fa ttinfo
 structure in the file
 (or simply the first
 .Fa ttinfo
 structure in the absence of a standard-time structure)
 if either
 .Va tzh_timecnt
 is zero or the time argument is less than the first transition time recorded
 in the file.
 .Pp
 For version-2-format time zone files,
 the above header and data are followed by a second header and data,
 identical in format except that
 eight bytes are used for each transition time or leap second time.
 After the second header and data comes a newline-enclosed,
 POSIX-TZ-environment-variable-style string for use in handling instants
 after the last transition time stored in the file
 (with nothing between the newlines if there is no POSIX representation for
 such instants).
 .Pp
 For version-3-format time zone files, the POSIX-TZ-style string may
 use two minor extensions to the POSIX TZ format, as described in
 .Xr tzset 3 .
 First, the hours part of its transition times may be signed and range from
 \(mi167 through 167 instead of the POSIX-required unsigned values
 from 0 through 24.
 Second, DST is in effect all year if it starts
 January 1 at 00:00 and ends December 31 at 24:00 plus the difference
 between daylight saving and standard time.
 .Pp
 Future changes to the format may append more data.
 .Sh SEE ALSO
 .Xr ctime 3 ,
 .Xr localtime 3 ,
 .Xr time 3 ,
 .Xr tzset 3 ,
 .Xr zdump 8
 .Xr zic 8
 .\" @(#)tzfile.5	8.3
 .\" This file is in the public domain, so clarified as of
 .\" 1996-06-05 by Arthur David Olson.

--- src/lib/libc/time/tzselect.8 2009/12/31 22:49:16	1.4
+++ src/lib/libc/time/tzselect.8 2013/09/20 19:06:54	1.5

 @@ -1,45 +1,115 @@
-.\"	$NetBSD: tzselect.8,v 1.4 2009/12/31 22:49:16 mlelstv Exp $
+.\"	$NetBSD: tzselect.8,v 1.5 2013/09/20 19:06:54 christos Exp $
 .\"
 .TH TZSELECT 8
 .SH NAME
 tzselect \- select a time zone
 .SH SYNOPSIS
 .B tzselect
+[
 .B \-c
 .I coord
 ] [
 .B \-n
 .I limit
 ] [
 .B \-\-help
 ] [
 .B \-\-version
+]
 .SH DESCRIPTION
 The
 .B tzselect
 program asks the user for information about the current location,
 and outputs the resulting time zone description to standard output.
 The output is suitable as a value for the TZ environment variable.
 .PP
 All interaction with the user is done via standard input and standard error.
 .SH OPTIONS
 .TP
 .BI "\-c " coord
 Instead of asking for continent and then country and then city,
 ask for selection from time zones whose largest cities
 are closest to the location with geographical coordinates
 .I coord.
 Use ISO 6709 notation for
 .I coord,
 that is, a latitude immediately followed by a longitude.  The latitude
 and longitude should be signed integers followed by an optional
 decimal point and fraction: positive numbers represent north and east,
 negative south and west.  Latitudes with two and longitudes with three
 integer digits are treated as degrees; latitudes with four or six and
 longitudes with five or seven integer digits are treated as
 .I "DDMM, DDDMM, DDMMSS,"
 or
 .I DDDMMSS
 representing
 .I DD
 or
 .I DDD
 degrees,
 .I MM
 minutes,
 and zero or
 .I SS
 seconds, with any trailing fractions represent fractional minutes or
 (if
 .I SS
 is present) seconds.  The decimal point is that of the current locale.
 For example, in the (default) C locale,
 .B "\-c\ +40.689\-074.045"
 specifies 40.689\(de\|N, 74.045\(de\|W,
 .B "\-c\ +4041.4\-07402.7"
 specifies 40\(de\|41.4\(fm\|N, 74\(de\|2.7\(fm\|W, and
 .B "\-c\ +404121\-0740240"
 specifies 40\(de\|41\(fm\|21\(sd\|N, 74\(de\|2\(fm\|40\(sd\|W.
 If
 .I coord
 is not one of the documented forms, the resulting behavior is unspecified.
 .TP
 .BI "\-n " limit
 When
 .B \-c
 is used, display the closest
 .I limit
 locations (default 10).
 .PP
 Applications should not assume that
 .BR tzselect 's
 output matches the user's political preferences.
 .RE
 .TP
 .B "\-\-help"
 Output help information and exit.
 .TP
 .B "\-\-version"
 Output version information and exit.
 .SH "ENVIRONMENT VARIABLES"
 .TP
 \f3AWK\fP
 Name of a Posix-compliant
 .I awk
 program (default:
 .BR awk ).
 .TP
 \f3TZDIR\fP
 Name of the directory containing time zone data files (default:
 .BR /usr/local/etc/zoneinfo ).
 .SH FILES
 .TP
 \f2TZDIR\fP\f3/iso3166.tab\fP
 Table of ISO 3166 2-letter country codes and country names.
 .TP
 \f2TZDIR\fP\f3/zone.tab\fP
-Table of country codes, latitude and longitude, TZ values, and
+Tables of country codes, latitude and longitude, zone names, and
 descriptive comments.
 .TP
 \f2TZDIR\fP\f3/\fP\f2TZ\fP
 Time zone data file for time zone \f2TZ\fP.
 .SH "EXIT STATUS"
 The exit status is zero if a time zone was successfully obtained from the user,
 nonzero otherwise.
 .SH "SEE ALSO"
 newctime(3), tzfile(5), zdump(8), zic(8)
 .\" @(#)tzselect.8	8.2
 .\" This file is in the public domain, so clarified as of
 .\" 2009-05-17 by Arthur David Olson.

--- src/lib/libc/time/tzselect.ksh 2013/03/02 21:24:28	1.8
+++ src/lib/libc/time/tzselect.ksh 2013/09/20 19:06:54	1.9

 @@ -1,16 +1,16 @@
 #! /bin/bash
+#
-#	$NetBSD: tzselect.ksh,v 1.8 2013/03/02 21:24:28 christos Exp $
+#	$NetBSD: tzselect.ksh,v 1.9 2013/09/20 19:06:54 christos Exp $
+#
 PKGVERSION='(tzcode) '
 TZVERSION=see_Makefile
 REPORT_BUGS_TO=tz@iana.org
 # Ask the user about the time zone, and output the resulting TZ value to stdout.
 # Interact with the user via stderr and stdin.
 # Contributed by Paul Eggert.
 # Porting notes:
+#
 # This script requires a Posix-like shell with the extension of a
 @@ -32,130 +32,279 @@ REPORT_BUGS_TO=tz@iana.org
 # Specify default values for environment variables if they are unset.
 : ${AWK=awk}
 : ${TZDIR=$(pwd)}
 # Check for awk Posix compliance.
 ($AWK -v x=y 'BEGIN { exit 123 }') </dev/null >/dev/null 2>&1
 [ $? = 123 ] || {
 	echo >&2 "$0: Sorry, your \`$AWK' program is not Posix compatible."
 	exit 1
+}
-if [ "$1" = "--help" ]; then
+coord=
-    cat <<EOF
+location_limit=10
 Usage: tzselect
 usage="Usage: tzselect [--version] [--help] [-c COORD] [-n LIMIT]
 Select a time zone interactively.
-Report bugs to $REPORT_BUGS_TO.
+Options:
 EOF
-    exit
+  -c COORD
-elif [ "$1" = "--version" ]; then
+    Instead of asking for continent and then country and then city,
-    cat <<EOF
+    ask for selection from time zones whose largest cities
-tzselect $TZVERSION
+    are closest to the location with geographical coordinates COORD.
-EOF
+    COORD should use ISO 6709 notation, for example, '-c +4852+00220'
-    exit
+    for Paris (in degrees and minutes, North and East), or
-fi
+    '-c -35-058' for Buenos Aires (in degrees, South and West).
   -n LIMIT
     Display at most LIMIT locations when -c is used (default $location_limit).
   --version
     Output version information.
   --help
     Output this help.
 Report bugs to $REPORT_BUGS_TO."
 while getopts c:n:-: opt
 do
     case $opt$OPTARG in
     c*)
 	coord=$OPTARG ;;
     n*)
 	location_limit=$OPTARG ;;
     -help)
 	exec echo "$usage" ;;
     -version)
 	exec echo "tzselect $PKGVERSION$TZVERSION" ;;
     -*)
 	echo >&2 "$0: -$opt$OPTARG: unknown option; try '$0 --help'"; exit 1 ;;
     *)
 	echo >&2 "$0: try '$0 --help'"; exit 1 ;;
     esac
 done
 shift $((OPTIND-1))
 case $# in
 ) ;;
 *) echo >&2 "$0: $1: unknown argument"; exit 1 ;;
 esac
 # Make sure the tables are readable.
 TZ_COUNTRY_TABLE=$TZDIR/iso3166.tab
 TZ_ZONE_TABLE=$TZDIR/zone.tab
 for f in $TZ_COUNTRY_TABLE $TZ_ZONE_TABLE
 do
 	<$f || {
 		echo >&2 "$0: time zone files are not set up correctly"
 		exit 1
+	}
 done
 newline='
+'
 IFS=$newline
 # Work around a bug in bash 1.14.7 and earlier, where $PS3 is sent to stdout.
 case $(echo 1 | (select x in x; do break; done) 2>/dev/null) in
 ?*) PS3=
 esac
 # Awk script to read a time zone table and output the same table,
 # with each column preceded by its distance from 'here'.
 output_distances='
   BEGIN {
     FS = "\t"
     while (getline <TZ_COUNTRY_TABLE)
       if ($0 ~ /^[^#]/)
         country[$1] = $2
     country["US"] = "US" # Otherwise the strings get too long.
+  }
   function convert_coord(coord, deg, min, ilen, sign, sec) {
     if (coord ~ /^[-+]?[0-9]?[0-9][0-9][0-9][0-9][0-9][0-9]([^0-9]|$)/) {
       degminsec = coord
       intdeg = degminsec < 0 ? -int(-degminsec / 10000) : int(degminsec / 10000)
       minsec = degminsec - intdeg * 10000
       intmin = minsec < 0 ? -int(-minsec / 100) : int(minsec / 100)
       sec = minsec - intmin * 100
       deg = (intdeg * 3600 + intmin * 60 + sec) / 3600
     } else if (coord ~ /^[-+]?[0-9]?[0-9][0-9][0-9][0-9]([^0-9]|$)/) {
       degmin = coord
       intdeg = degmin < 0 ? -int(-degmin / 100) : int(degmin / 100)
       min = degmin - intdeg * 100
       deg = (intdeg * 60 + min) / 60
     } else
       deg = coord
     return deg * 0.017453292519943296
+  }
   function convert_latitude(coord) {
     match(coord, /..*[-+]/)
     return convert_coord(substr(coord, 1, RLENGTH - 1))
+  }
   function convert_longitude(coord) {
     match(coord, /..*[-+]/)
     return convert_coord(substr(coord, RLENGTH))
+  }
   # Great-circle distance between points with given latitude and longitude.
   # Inputs and output are in radians.  This uses the great-circle special
   # case of the Vicenty formula for distances on ellipsoids.
   function dist(lat1, long1, lat2, long2, dlong, x, y, num, denom) {
     dlong = long2 - long1
     x = cos (lat2) * sin (dlong)
     y = cos (lat1) * sin (lat2) - sin (lat1) * cos (lat2) * cos (dlong)
     num = sqrt (x * x + y * y)
     denom = sin (lat1) * sin (lat2) + cos (lat1) * cos (lat2) * cos (dlong)
     return atan2(num, denom)
+  }
   BEGIN {
     coord_lat = convert_latitude(coord)
     coord_long = convert_longitude(coord)
+  }
   /^[^#]/ {
     here_lat = convert_latitude($2)
     here_long = convert_longitude($2)
     line = $1 "\t" $2 "\t" $3 "\t" country[$1]
     if (NF == 4)
       line = line " - " $4
     printf "%g\t%s\n", dist(coord_lat, coord_long, here_lat, here_long), line
+  }
+'
 # Begin the main loop.  We come back here if the user wants to retry.
 while
 	echo >&2 'Please identify a location' \
 		'so that time zone rules can be set correctly.'
 	continent=
 	country=
 	region=
 	case $coord in
 	?*)
 		continent=coord;;
 	'')
 	# Ask the user for continent or ocean.
-	echo >&2 'Please select a continent or ocean.'
+	echo >&2 'Please select a continent, ocean, "coord", or "TZ".'
-	select continent in \
+        quoted_continents=$(
-	    Africa \
+	  $AWK -F'\t' '
-	    Americas \
+	    /^[^#]/ {
-	    Antarctica \
+              entry = substr($3, 1, index($3, "/") - 1)
-	    'Arctic Ocean' \
+              if (entry == "America")
-	    Asia \
+		entry = entry "s"
-	    'Atlantic Ocean' \
+              if (entry ~ /^(Arctic|Atlantic|Indian|Pacific)$/)
-	    Australia \
+		entry = entry " Ocean"
-	    Europe \
+              printf "'\''%s'\''\n", entry
 	    'Indian Ocean' \
-	    'Pacific Ocean' \
+          ' $TZ_ZONE_TABLE |
-	    'none - I want to specify the time zone using the Posix TZ format.'
+	  sort -u |
-	do
+	  tr '\n' ' '
-	    case $continent in
+	  echo ''
 	    '')
 		echo >&2 'Please enter a number in range.';;
-	    ?*)
+	eval '
 	    select continent in '"$quoted_continents"' \
 		"coord - I want to use geographical coordinates." \
 		"TZ - I want to specify the time zone using the Posix TZ format."
 	    do
 		case $continent in
-		Americas) continent=America;;
+		"")
-		*' '*) continent=$(expr "$continent" : '\([^ ]*\)')
+		    echo >&2 "Please enter a number in range.";;
 		?*)
 		    case $continent in
 		    Americas) continent=America;;
 		    *" "*) continent=$(expr "$continent" : '\''\([^ ]*\)'\'')
 		    esac
 		    break
 		esac
-		break
+	    done
 	    esac
-	done
+	esac
 	case $continent in
 	'')
 		exit 1;;
-	none)
+	TZ)
 		# Ask the user for a Posix TZ string.  Check that it conforms.
 		while
 			echo >&2 'Please enter the desired value' \
 				'of the TZ environment variable.'
 			echo >&2 'For example, GST-10 is a zone named GST' \
 				'that is 10 hours ahead (east) of UTC.'
 			read TZ
 			$AWK -v TZ="$TZ" 'BEGIN {
 				tzname = "[^-+,0-9][^-+,0-9][^-+,0-9]+"
 				time = "[0-2]?[0-9](:[0-5][0-9](:[0-5][0-9])?)?"
 				offset = "[-+]?" time
 				date = "(J?[0-9]+|M[0-9]+\.[0-9]+\.[0-9]+)"
 				datetime = "," date "(/" time ")?"
 				tzpattern = "^(:.*|" tzname offset "(" tzname \
 				  "(" offset ")?(" datetime datetime ")?)?)$"
 				if (TZ ~ tzpattern) exit 1
 				exit 0
 			}'
 		do
 			echo >&2 "\`$TZ' is not a conforming" \
 				'Posix time zone string.'
 		done
 		TZ_for_date=$TZ;;
 	*)
 		case $continent in
 		coord)
 		    case $coord in
 		    '')
 			echo >&2 'Please enter coordinates' \
 				'in ISO 6709 notation.'
 			echo >&2 'For example, +4042-07403 stands for'
 			echo >&2 '40 degrees 42 minutes north,' \
 				'74 degrees 3 minutes west.'
 			read coord;;
 		    esac
 		    distance_table=$($AWK \
 			    -v coord="$coord" \
 			    -v TZ_COUNTRY_TABLE="$TZ_COUNTRY_TABLE" \
 			    "$output_distances" <$TZ_ZONE_TABLE |
 		      sort -n |
 		      sed "${location_limit}q"
+		    )
 		    regions=$(echo "$distance_table" | $AWK '
 		      BEGIN { FS = "\t" }
 		      { print $NF }
 		    ')
 		    echo >&2 'Please select one of the following' \
 			    'time zone regions,'
 		    echo >&2 'listed roughly in increasing order' \
 			    "of distance from $coord".
 		    select region in $regions
 		    do
 			case $region in
 			'') echo >&2 'Please enter a number in range.';;
 			?*) break;;
 			esac
 		    done
 		    TZ=$(echo "$distance_table" | $AWK -v region="$region" '
 		      BEGIN { FS="\t" }
 		      $NF == region { print $4 }
 		    ')
 		    ;;
 		*)
 		# Get list of names of countries in the continent or ocean.
 		countries=$($AWK -F'\t' \
 			-v continent="$continent" \
 			-v TZ_COUNTRY_TABLE="$TZ_COUNTRY_TABLE" \
+		'
 			/^#/ { next }
 			$3 ~ ("^" continent "/") {
 				if (!cc_seen[$1]++) cc_list[++ccs] = $1
+			}
 			END {
 				while (getline <TZ_COUNTRY_TABLE) {
 					if ($0 !~ /^#/) cc_name[$1] = $2
+				}
 @@ -163,27 +312,28 @@ while
 					country = cc_list[i]
 					if (cc_name[country]) {
 					  country = cc_name[country]
+					}
 					print country
+				}
+			}
 		' <$TZ_ZONE_TABLE | sort -f)
 		# If there's more than one country, ask the user which one.
 		case $countries in
 		*"$newline"*)
-			echo >&2 'Please select a country.'
+			echo >&2 'Please select a country' \
 				'whose clocks agree with yours.'
 			select country in $countries
 			do
 			    case $country in
 			    '') echo >&2 'Please enter a number in range.';;
 			    ?*) break
 			    esac
 			done
 			case $country in
 			'') exit 1
 			esac;;
 		*)
 			country=$countries
 @@ -234,26 +384,27 @@ while
 			-v TZ_COUNTRY_TABLE="$TZ_COUNTRY_TABLE" \
+		'
 			BEGIN {
 				cc = country
 				while (getline <TZ_COUNTRY_TABLE) {
 					if ($0 !~ /^#/  &&  country == $2) {
 						cc = $1
 						break
+					}
+				}
+			}
 			$1 == cc && $4 == region { print $3 }
 		' <$TZ_ZONE_TABLE)
 		esac
 		# Make sure the corresponding zoneinfo file exists.
 		TZ_for_date=$TZDIR/$TZ
 		<$TZ_for_date || {
 			echo >&2 "$0: time zone files are not set up correctly"
 			exit 1
+		}
 	esac
 	# Use the proposed TZ to output the current date relative to UTC.
 	# Loop until they agree in seconds.
 	# Give up after 8 unsuccessful tries.
 @@ -270,48 +421,50 @@ while
 			extra_info="
 Local time is now:	$TZdate.
 Universal Time is now:	$UTdate."
 			break
 		esac
 	done
 	# Output TZ info and ask the user to confirm.
 	echo >&2 ""
 	echo >&2 "The following information has been given:"
 	echo >&2 ""
-	case $country+$region in
+	case $country%$region%$coord in
-	?*+?*)	echo >&2 "	$country$newline	$region";;
+	?*%?*%)	echo >&2 "	$country$newline	$region";;
-	?*+)	echo >&2 "	$country";;
+	?*%%)	echo >&2 "	$country";;
 	%?*%?*) echo >&2 "	coord $coord$newline	$region";;
 	%%?*)	echo >&2 "	coord $coord";;
 	+)	echo >&2 "	TZ='$TZ'"
 	esac
 	echo >&2 ""
 	echo >&2 "Therefore TZ='$TZ' will be used.$extra_info"
 	echo >&2 "Is the above information OK?"
 	ok=
 	select ok in Yes No
 	do
 	    case $ok in
 	    '') echo >&2 'Please enter 1 for Yes, or 2 for No.';;
 	    ?*) break
 	    esac
 	done
 	case $ok in
 	'') exit 1;;
 	Yes) break
 	esac
-do :
+do coord=
 done
 case $SHELL in
 *csh) file=.login line="setenv TZ '$TZ'";;
 *) file=.profile line="TZ='$TZ'; export TZ"
 esac
 echo >&2 "
 You can make this change permanent for yourself by appending the line
 	$line
 to the file '$file' in your home directory; then log out and log in again.
 Here is that TZ value again, this time on standard output so that you

--- src/lib/libc/time/tzset.3 2010/12/17 01:29:45	1.25
+++ src/lib/libc/time/tzset.3 2013/09/20 19:06:54	1.26

 @@ -1,15 +1,15 @@
-.\"	$NetBSD: tzset.3,v 1.25 2010/12/17 01:29:45 wiz Exp $
+.\"	$NetBSD: tzset.3,v 1.26 2013/09/20 19:06:54 christos Exp $
-.Dd April 1, 2001
+.Dd September 20, 2013
 .Dt TZSET 3
 .Os
 .Sh NAME
 .Nm tzset
 .Nd initialize time conversion information
 .Sh LIBRARY
 .Lb libc
 .Sh SYNOPSIS
 .In time.h
 .Ft void
 .Fn tzset "void"
 .Sh DESCRIPTION
 The
 @@ -21,28 +21,30 @@ to set time conversion information used
 If
 .Ev TZ
 does not appear in the environment,
 the best available approximation to local wall clock time, as
 specified by the
 .Xr tzfile 5
 format file
 .Pa /etc/localtime
 is used by
 .Xr localtime 3 .
 If
 .Ev TZ
 appears in the environment but its value is a null string,
-Coordinated Universal Time (UTC) is used (without leap second
+Universal Time (UT) is used, with the abbreviation
-correction).
+.Dq UTC
 and without leap second correction; please see
 .Xr ctime 3 .
 If
 .Ev TZ
 appears in the environment and its value is not a null string:
 .Bl -dash
 .It
 if the value begins with a colon, it is used as a pathname of a file
 from which to read the time conversion information;
 .It
 if the value does not begin with a colon, it is first used as the
 pathname of a file from which to read the time conversion information,
 and, if that file cannot be read, is used directly as a specification
 of the time conversion information.
 .El
 @@ -141,26 +143,30 @@ has the form:
 .Ed
 .Sm on
 .Pp
 where the first
 .Cm date
 describes when the change from standard to summer time occurs and the
 second
 .Cm date
 describes when the change back happens.
 Each
 .Cm time
 field describes when, in current local time, the change to the other
 time is made.
 As an extension to POSIX, daylight saving is assumed to be in effect
 all year if it begins January 1 at 00:00 and ends December 31 at
 :00 plus the difference between daylight saving and standard time,
 leaving no room for standard time in the calendar.
 The format of
 .Fa date
 is one of the following:
 .Bl -tag -width "The Julian day" -compact
 .It Cm J Ns Ar n
 The Julian day
 .Ar n
 (1 \*[Le]
 .Ar n
 \*[Le] 365).
 Leap days are not counted; that is, in all years \(em including leap
 years \(em February 28 is day 59 and March 1 is day 60.
 It is impossible to explicitly refer to the occasional February 29.
 @@ -189,36 +195,77 @@ of the year
 .Ar m
 \*[Le]\ 12, where week 5 means
 .Dq the\ last Ar d No day\ in\ month Ar m
 which may occur in either the fourth or the fifth week).
 Week 1 is the first week in which the
 .Ar d Ns 'th
 day occurs.
 Day zero is Sunday.
 .El
 The
 .Cm time
 has the same format as
 .Cm offset
-except that no leading sign
+except that POSIX does not allow a leading sign
 .Dq -
 or
 .Dq +
 is allowed.
 As an extension to POSIX, the hours part of
 .Cm time
 can range from \(mi167 through 167; this allows for unusual rules such as
 .Dq the Saturday before the first Sunday of March .
 The default, if
 .Cm time
 is not given, is
 .Cm 02:00:00 .
 .El
 .Pp
 Here are some examples of
 .Va TZ
 values that directly specify the time zone rules; they use some of the
 extensions to POSIX.
 .Bl -tag
 .It EST5
 stands for US eastern
 time (EST), 5 hours behind UTC, without daylight saving.
 .It FJT\(mi12FJST,M10.3.1/146,M1.3.4/75
 stands for Fiji Time (FJT) and Fiji Summer Time (FJST), 12 hours ahead
 of UTC, springing forward on October's third Monday at
 :00 (i.e., 02:00 on the first Sunday on or after October 21), and
 falling back on January's third Thursday at 75:00 (i.e., 03:00 on the
 first Sunday on or after January 18).
 .It IST\(mi2IDT,M3.4.4/26,M10.5.0
 stands for Israel Standard Time (IST) and Israel Daylight Time (IDT),
 hours ahead of UTC, springing forward on March's fourth
 Tuesday at 26:00 (i.e., 02:00 on the first Friday on or after March
 ), and falling back on October's last Sunday at 02:00.
 .It WART4WARST,J1/0,J365/25
 stands for Western Argentina Summer Time (WARST), 3 hours behind UTC.
 There is a dummy fall-back transition on December 31 at 25:00 daylight
 saving time (i.e., 24:00 standard time, equivalent to January 1 at
 :00 standard time), and a simultaneous spring-forward transition on
 January 1 at 00:00 standard time, so daylight saving time is in effect
 all year and the initial
 .Em WART
 is a placeholder.
 .It WGT3WGST,M3.5.0/\(mi2,M10.5.0/\(mi1
 stands for Western Greenland time (WGT) and Western Greenland Summer
 Time (WGST), 3 hours behind UTC, where clocks follow the EU rules of
 springing forward on March's last Sunday at 01:00 UTC (\(mi02:00 local
 time) and falling back on October's last Sunday at 01:00 UTC
 (\(mi01:00 local time).
 .El
 .Pp
 If no
 .Cm rule
 is present in
 .Ev TZ ,
 the rules specified by the
 .Xr tzfile 5
 format file
 .Pa posixrules
 in
 .Pa /usr/share/zoneinfo
 are used, with the standard and summer time offsets from UTC replaced
 by those specified by the
 .Cm offset

--- src/lib/libc/time/Attic/version.h 2012/08/09 12:38:26	1.1
+++ src/lib/libc/time/Attic/version.h 2013/09/20 19:06:54	1.2

--- src/lib/libc/time/zdump.8 2013/07/17 20:13:04	1.10
+++ src/lib/libc/time/zdump.8 2013/09/20 19:06:54	1.11

 @@ -1,15 +1,15 @@
-.\"	$NetBSD: zdump.8,v 1.10 2013/07/17 20:13:04 christos Exp $
+.\"	$NetBSD: zdump.8,v 1.11 2013/09/20 19:06:54 christos Exp $
-.Dd July 17, 2013
+.Dd September 20, 2013
 .Dt ZDUMP 8
 .Os
 .Sh NAME
 .Nm zdump
 .Nd time zone dumper
 .Sh SYNOPSIS
 .Nm zdump
 .Op Fl \-version
 .Op Fl v
 .Op Fl V
 .Op Fl c Ar [loyear,]highyear
 .Op Ar zonename ...
 .Nm zdump
 @@ -46,31 +46,37 @@ Cut off the verbose output near the star
 By default,
 the program cuts off verbose output near the starts of the years \-500 and 2500.
 .It Fl t Ar [loyear,]highyear
 Cut off verbose output at the start of the given time(s),
 given in decimal seconds since 1970-01-01 00:00:00 UTC.
 .It Fl V
 Like
 .Fl v ,
 except omit the times relative to the extreme time values.
 This generates output that is easier to compare to that of
 implementations with different time representations.
 .El
 .Sh LIMITATIONS
 The
 .Fl v
 and
 .Fl V
 options may not be used on systems with floating-point time_t values
 that are neither float nor double.
 .Pp
 Time discontinuities are found by sampling the results returned by localtime
 at twelve-hour intervals.
 This works in all real-world cases;
 one can construct artificial time zones for which this fails.
 .Pp
 In the output,
 .Dq UT
 denotes the value returned by
 .Xr gmtime 3 ,
 which uses UTC for modern time stamps and some other UT flavor for
 time stamps that predate the introduction of UTC.
 No attempt is currently made to have the output use
 .Dq UTC
 for newer and
 .Dq UT
 for older time stamps,
 partly because the exact date of the introduction of UTC is problematic.
 .Sh SEE ALSO
 .Xr ctime 3 ,
 .Xr tzfile 5 ,
 .Xr zic 8
 .\" @(#)zdump.8	8.2
 .\" This file is in the public domain, so clarified as of
 .\" 2009-05-17 by Arthur David Olson.

--- src/lib/libc/time/zdump.c 2013/07/17 23:09:26	1.30
+++ src/lib/libc/time/zdump.c 2013/09/20 19:06:54	1.31

 @@ -1,43 +1,42 @@
-/*	$NetBSD: zdump.c,v 1.30 2013/07/17 23:09:26 christos Exp $	*/
+/*	$NetBSD: zdump.c,v 1.31 2013/09/20 19:06:54 christos Exp $	*/
 /*
 ** This file is in the public domain, so clarified as of
 ** 2009-05-17 by Arthur David Olson.
 */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: zdump.c,v 1.30 2013/07/17 23:09:26 christos Exp $");
+__RCSID("$NetBSD: zdump.c,v 1.31 2013/09/20 19:06:54 christos Exp $");
 #endif /* !defined lint */
 #include "version.h"
 /*
 ** This code has been made independent of the rest of the time
 ** conversion package to increase confidence in the verification it provides.
 ** You can use this code to help in verifying other implementations.
 **
 ** However, include private.h when debugging, so that it overrides
 ** time_t consistently with the rest of the package.
 */
 #include "private.h"
 #include "stdio.h"	/* for stdout, stderr */
 #include "string.h"	/* for strcpy */
 #include "sys/types.h"	/* for time_t */
 #include "time.h"	/* for struct tm */
 #include "stdlib.h"	/* for exit, malloc, atoi */
 #include <err.h>
 #include "float.h"	/* for FLT_MAX and DBL_MAX */
 #include "ctype.h"	/* for isalpha et al. */
 #ifndef isascii
 #define isascii(x) 1
 #endif /* !defined isascii */
 /*
 ** Substitutes for pre-C99 compilers.
 ** Much of this section of code is stolen from private.h.
 */
 #ifndef HAVE_STDINT_H
 # define HAVE_STDINT_H \
     (199901 <= __STDC_VERSION__ || 2 < (__GLIBC__ + (0 < __GLIBC_MINOR__)))
 @@ -54,29 +53,35 @@ __RCSID("$NetBSD: zdump.c,v 1.30 2013/07
 #ifndef INT_FAST32_MAX
 # if INT_MAX >> 31 == 0
 typedef long int_fast32_t;
 # else
 typedef int int_fast32_t;
 # endif
 #endif
 #ifndef INTMAX_MAX
 # if defined LLONG_MAX || defined __LONG_LONG_MAX__
 typedef long long intmax_t;
 #  define PRIdMAX "lld"
 #  ifdef LLONG_MAX
 #   define INTMAX_MAX LLONG_MAX
 #  else
 #   define INTMAX_MAX __LONG_LONG_MAX__
 #  endif
 # else
 typedef long intmax_t;
 #  define PRIdMAX "ld"
 #  define INTMAX_MAX LONG_MAX
 # endif
 #endif
 #ifndef SCNdMAX
 # define SCNdMAX PRIdMAX
 #endif
 #ifndef ZDUMP_LO_YEAR
 #define ZDUMP_LO_YEAR	(-500)
 #endif /* !defined ZDUMP_LO_YEAR */
 #ifndef ZDUMP_HI_YEAR
 #define ZDUMP_HI_YEAR	2500
 @@ -134,26 +139,37 @@ typedef long intmax_t;
 #define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
 #endif /* !defined isleap */
 #ifndef isleap_sum
 /*
 ** See tzfile.h for details on isleap_sum.
 */
 #define isleap_sum(a, b)	isleap((a) % 400 + (b) % 400)
 #endif /* !defined isleap_sum */
 #define SECSPERDAY	((int_fast32_t) SECSPERHOUR * HOURSPERDAY)
 #define SECSPERNYEAR	(SECSPERDAY * DAYSPERNYEAR)
 #define SECSPERLYEAR	(SECSPERNYEAR + SECSPERDAY)
 #define SECSPER400YEARS	(SECSPERNYEAR * (intmax_t) (300 + 3)	\
 			 + SECSPERLYEAR * (intmax_t) (100 - 3))
 /*
 ** True if SECSPER400YEARS is known to be representable as an
 ** intmax_t.  It's OK that SECSPER400YEARS_FITS can in theory be false
 ** even if SECSPER400YEARS is representable, because when that happens
 ** the code merely runs a bit more slowly, and this slowness doesn't
 ** occur on any practical platform.
 */
 enum { SECSPER400YEARS_FITS = SECSPERLYEAR <= INTMAX_MAX / 400 };
 #ifndef HAVE_GETTEXT
 #define HAVE_GETTEXT 0
 #endif
 #if HAVE_GETTEXT
 #include "locale.h"	/* for setlocale */
 #include "libintl.h"
 #endif /* HAVE_GETTEXT */
 #ifndef GNUC_or_lint
 #ifdef lint
 #define GNUC_or_lint
 #else /* !defined lint */
 @@ -195,77 +211,62 @@ typedef long intmax_t;
 #ifndef TZ_DOMAIN
 #define TZ_DOMAIN "tz"
 #endif /* !defined TZ_DOMAIN */
 extern char **	environ;
 extern int	getopt(int argc, char * const argv[],
 			const char * options);
 extern char *	optarg;
 extern int	optind;
 /* The minimum and maximum finite time values.  */
 static time_t	absolute_min_time =
-   ((time_t) 0.5 == 0.5
+  ((time_t) -1 < 0
     ? (sizeof (time_t) == sizeof (float) ? (time_t) -FLT_MAX
        : sizeof (time_t) == sizeof (double) ? (time_t) -DBL_MAX
        : sizeof (time_t) == sizeof (long double) ? (time_t) -LDBL_MAX
        : 0)
 #ifndef TIME_T_FLOATING
     : (time_t) -1 < 0
     ? (time_t) -1 << (CHAR_BIT * sizeof (time_t) - 1)
 #endif
     : 0);
 static time_t	absolute_max_time =
-  ((time_t) 0.5 == 0.5
+  ((time_t) -1 < 0
-   ? (sizeof (time_t) == sizeof (float) ? (time_t) FLT_MAX
+    ? - (~ 0 < 0) - ((time_t) -1 << (CHAR_BIT * sizeof (time_t) - 1))
       : sizeof (time_t) == sizeof (double) ? (time_t) DBL_MAX
       : sizeof (time_t) == sizeof (long double) ? (time_t) LDBL_MAX
       : -1)
 #ifndef TIME_T_FLOATING
    : (time_t) -1 < 0
    ? - (~ 0 < 0) - ((time_t) -1 << (CHAR_BIT * sizeof (time_t) - 1))
 #endif
    : -1);
 static size_t	longest;
 static char *	progname;
 static int	warned;
 static const char *	abbr(struct tm * tmp);
 static void	abbrok(const char * abbrp, const char * zone);
 static intmax_t	delta(struct tm * newp, struct tm * oldp) ATTRIBUTE_PURE;
 static void	dumptime(const struct tm * tmp);
 static time_t	hunt(char * name, time_t lot, time_t	hit);
 static void	checkabsolutes(void);
 static void	show(char * zone, time_t t, int v);
 static const char *	tformat(void);
 static time_t	yeartot(long y) ATTRIBUTE_PURE;
 #ifndef TYPECHECK
 #define my_localtime	localtime
 #else /* !defined TYPECHECK */
 static struct tm *
 my_localtime(time_t *tp)
+{
 	struct tm *tmp;
 	tmp = localtime(tp);
 	if (tp != NULL && tmp != NULL) {
 		struct tm	tm;
 		time_t	t;
 		tm = *tmp;
 		t = mktime(&tm);
-		if (t - *tp >= 1 || *tp - t >= 1) {
+		if (t != *tp) {
 			(void) fflush(stdout);
 			(void) fprintf(stderr, "\n%s: ", progname);
 			(void) fprintf(stderr, tformat(), *tp);
 			(void) fprintf(stderr, " ->");
 			(void) fprintf(stderr, " year=%d", tmp->tm_year);
 			(void) fprintf(stderr, " mon=%d", tmp->tm_mon);
 			(void) fprintf(stderr, " mday=%d", tmp->tm_mday);
 			(void) fprintf(stderr, " hour=%d", tmp->tm_hour);
 			(void) fprintf(stderr, " min=%d", tmp->tm_min);
 			(void) fprintf(stderr, " sec=%d", tmp->tm_sec);
 			(void) fprintf(stderr, " isdst=%d", tmp->tm_isdst);
 			(void) fprintf(stderr, " -> ");
 			(void) fprintf(stderr, tformat(), t);
 @@ -385,27 +386,26 @@ main(int argc, char *argv[])
 		if (cutarg != NULL) {
 			if (sscanf(cutarg, "%"SCNdMAX"%c", &hi, &dummy) == 1) {
 				cuthiyear = hi;
 			} else if (sscanf(cutarg, "%"SCNdMAX",%"SCNdMAX"%c",
 				&lo, &hi, &dummy) == 2) {
 					cutloyear = lo;
 					cuthiyear = hi;
 			} else {
 (void) fprintf(stderr, _("%s: wild -c argument %s\n"),
 					progname, cutarg);
 				exit(EXIT_FAILURE);
+			}
+		}
 		checkabsolutes();
 		if (cutarg != NULL || cuttimes == NULL) {
 			cutlotime = yeartot(cutloyear);
 			cuthitime = yeartot(cuthiyear);
+		}
 		if (cuttimes != NULL) {
 			if (sscanf(cuttimes, "%"SCNdMAX"%c", &hi, &dummy) == 1) {
 				if (hi < cuthitime) {
 					if (hi < absolute_min_time)
 						hi = absolute_min_time;
 					cuthitime = hi;
+				}
 			} else if (sscanf(cuttimes, "%"SCNdMAX",%"SCNdMAX"%c",
 					  &lo, &hi, &dummy) == 2) {
 @@ -454,114 +454,117 @@ main(int argc, char *argv[])
+	}
 	for (i = optind; i < argc; ++i) {
 		static char	buf[MAX_STRING_LENGTH];
 		(void) strcpy(&fakeenv[0][3], argv[i]);	/* XXX strcpy is safe */
 		if (! (vflag | Vflag)) {
 			show(argv[i], now, FALSE);
 			continue;
+		}
 		warned = FALSE;
 		t = absolute_min_time;
 		if (!Vflag) {
 			show(argv[i], t, TRUE);
-			t += SECSPERHOUR * HOURSPERDAY;
+			t += SECSPERDAY;
 			show(argv[i], t, TRUE);
+		}
 		if (t < cutlotime)
 			t = cutlotime;
 		tmp = my_localtime(&t);
 		if (tmp != NULL) {
 			tm = *tmp;
 			(void) strncpy(buf, abbr(&tm), (sizeof buf) - 1);
+		}
 		for ( ; ; ) {
-			if (t >= cuthitime || t >= cuthitime - SECSPERHOUR * 12)
+			newt = (t < absolute_max_time - SECSPERDAY / 2
 				? t + SECSPERDAY / 2
 				: absolute_max_time);
 			if (cuthitime <= newt)
 				break;
 			newt = t + SECSPERHOUR * 12;
 			newtmp = localtime(&newt);
 			if (newtmp != NULL)
 				newtm = *newtmp;
 			if ((tmp == NULL || newtmp == NULL) ? (tmp != newtmp) :
 				(delta(&newtm, &tm) != (newt - t) ||
 				newtm.tm_isdst != tm.tm_isdst ||
 				strcmp(abbr(&newtm), buf) != 0)) {
 					newt = hunt(argv[i], t, newt);
 					newtmp = localtime(&newt);
 					if (newtmp != NULL) {
 						newtm = *newtmp;
 						(void) strncpy(buf,
 							abbr(&newtm),
 							(sizeof buf) - 1);
+					}
+			}
 			t = newt;
 			tm = newtm;
 			tmp = newtmp;
+		}
 		if (!Vflag) {
 			t = absolute_max_time;
-			t -= SECSPERHOUR * HOURSPERDAY;
+			t -= SECSPERDAY;
 			show(argv[i], t, TRUE);
-			t += SECSPERHOUR * HOURSPERDAY;
+			t += SECSPERDAY;
 			show(argv[i], t, TRUE);
+		}
+	}
 	if (fflush(stdout) || ferror(stdout)) {
 		err(EXIT_FAILURE, _("Error writing standard output"));
+	}
 	exit(EXIT_SUCCESS);
 	/* If exit fails to exit... */
 	return EXIT_FAILURE;
+}
 static void
 checkabsolutes(void)
 	if (absolute_max_time < absolute_min_time) {
 		(void) fprintf(stderr,
 _("%s: use of -v on system with floating time_t other than float or double\n"),
 			       progname);
 		exit(EXIT_FAILURE);
 static time_t
 yeartot(const long y)
+{
-	intmax_t	myy;
+	intmax_t	myy, seconds, years;
 	int_fast32_t	seconds;
 	time_t		t;
 	myy = EPOCH_YEAR;
 	t = 0;
-	while (myy != y) {
+	while (myy < y) {
-		if (myy < y) {
+		if (SECSPER400YEARS_FITS && 400 <= y - myy) {
 			intmax_t diff400 = (y - myy) / 400;
 			if (INTMAX_MAX / SECSPER400YEARS < diff400)
 				return absolute_max_time;
 			seconds = diff400 * SECSPER400YEARS;
 			years = diff400 * 400;
                 } else {
 			seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
-			++myy;
+			years = 1;
 			if (t > absolute_max_time - seconds) {
-				t = absolute_max_time;
+		myy += years;
-				break;
+		if (t > absolute_max_time - seconds)
 			return absolute_max_time;
-			t += seconds;
+		t += seconds;
+	}
 	while (y < myy) {
 		if (SECSPER400YEARS_FITS && y + 400 <= myy && myy < 0) {
 			intmax_t diff400 = (myy - y) / 400;
 			if (INTMAX_MAX / SECSPER400YEARS < diff400)
 				return absolute_min_time;
 			seconds = diff400 * SECSPER400YEARS;
 			years = diff400 * 400;
 		} else {
-			--myy;
+			seconds = isleap(myy - 1) ? SECSPERLYEAR : SECSPERNYEAR;
-			seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
+			years = 1;
 			if (t < absolute_min_time + seconds) {
 				t = absolute_min_time;
 				break;
 			t -= seconds;
+		}
 		myy -= years;
 		if (t < absolute_min_time + seconds)
 			return absolute_min_time;
 		t -= seconds;
+	}
 	return t;
+}
 static time_t
 hunt(char *name, time_t lot, time_t hit)
+{
 	time_t			t;
 	struct tm		lotm;
 	struct tm *	lotmp;
 	struct tm		tm;
 	struct tm *	tmp;
 	char			loab[MAX_STRING_LENGTH];
 @@ -625,27 +628,27 @@ delta(struct tm *newp, struct tm *oldp)
 static void
 show(char *zone, time_t t, int v)
+{
 	struct tm *	tmp;
 	(void) printf("%-*s  ", (int) longest, zone);
 	if (v) {
 		tmp = gmtime(&t);
 		if (tmp == NULL) {
 			(void) printf(tformat(), t);
 		} else {
 			dumptime(tmp);
-			(void) printf(" UTC");
+			(void) printf(" UT");
+		}
 		(void) printf(" = ");
+	}
 	tmp = my_localtime(&t);
 	dumptime(tmp);
 	if (tmp != NULL) {
 		if (*abbr(tmp) != '\0')
 			(void) printf(" %s", abbr(tmp));
 		if (v) {
 			(void) printf(" isdst=%d", tmp->tm_isdst);
 #ifdef TM_GMTOFF
 			(void) printf(" gmtoff=%ld", tmp->TM_GMTOFF);
 #endif /* defined TM_GMTOFF */
 @@ -666,31 +669,26 @@ abbr(struct tm *tmp)
 		return &nada;
 	result = tzname[tmp->tm_isdst];
 	return (result == NULL) ? &nada : result;
+}
 /*
 ** The code below can fail on certain theoretical systems;
 ** it works on all known real-world systems as of 2004-12-30.
 */
 static const char *
 tformat(void)
+{
 	if (0.5 == (time_t) 0.5) {	/* floating */
 		if (sizeof (time_t) > sizeof (double))
 			return "%Lg";
 		return "%g";
 	if (0 > (time_t) -1) {		/* signed */
 		if (sizeof (time_t) == sizeof (intmax_t))
 			return "%"PRIdMAX;
 		if (sizeof (time_t) > sizeof (long))
 			return "%lld";
 		if (sizeof (time_t) > sizeof (int))
 			return "%ld";
 		return "%d";
+	}
 #ifdef PRIuMAX
 	if (sizeof (time_t) == sizeof (uintmax_t))
 		return "%"PRIuMAX;
 #endif

--- src/lib/libc/time/zic.8 2012/08/09 12:38:26	1.20
+++ src/lib/libc/time/zic.8 2013/09/20 19:06:54	1.21

 @@ -1,15 +1,15 @@
-.\"	$NetBSD: zic.8,v 1.20 2012/08/09 12:38:26 christos Exp $
+.\"	$NetBSD: zic.8,v 1.21 2013/09/20 19:06:54 christos Exp $
-.Dd December 20, 2003
+.Dd September 20, 2013
 .Dt ZIC 8
 .Os
 .Sh NAME
 .Nm zic
 .Nd time zone compiler
 .Sh SYNOPSIS
 .Nm
 .Op Fl \-version
 .Op Fl d Ar directory
 .Op Fl L Ar leapsecondfilename
 .Op Fl l Ar localtime
 .Op Fl p Ar posixrules
 .Op Fl s
 @@ -43,42 +43,63 @@ Use the given time zone as local time.
 will act as if the input contained a link line of the form
 .Dl Link	timezone	localtime
 .It Fl p Ar timezone
 Use the given time zone's rules when handling POSIX-format
 time zone environment variables.
 .Nm
 will act as if the input contained a link line of the form
 .Dl Link	timezone	posixrules
 .It Fl s
 Limit time values stored in output files to values that are the same
 whether they're taken to be signed or unsigned.
 You can use this option to generate SVVS-compatible files.
 .It Fl v
-Complain if a year that appears in a data file is outside the range
+Be more verbose, and complain about the following situations:
-of years representable by
+.Bl -dash
-.Xr time 3
+.It The input data specifies a link to a link.
-values.
+.It A year that appears in a data file is outside the range
-Also complain if a time of 24:00
+.It A time of 24:00 or more appears in the input.
-.Pq which cannot be handled by pre-1998 versions of Nm
+Pre-1998 versions of
-appears in the input.
+.Xr zic 8
 prohibit 24:00, and pre-2007 versions prohibit times greater than 24:00.
 .It A rule goes past the start or end of the month.
 Pre-2004 versions of
 .Xr zic 8
 prohibit this.
 .It The output file does not contain all the information about the
 long-term future of a zone, because the future cannot be summarized as
 an extended POSIX TZ string.
 For example, as of 2013 this problem
 occurs for Iran's daylight-saving rules for the predicted future, as
 these rules are based on the Iranian calendar, which cannot be
 represented.
 .It The output contains data that may not be handled properly by client
 code designed for older
 .Xr zic 8
 output formats.
 These compatibility issues affect only time stamps
 before 1970 or after the start of 2038.
 .It A time zone abbreviation has fewer than 3 characters.
 POSIX requires at least 3.
 .El
 .It Fl y Ar command
 Use the given
 .Ar command
 rather than
 .Em yearistype
 when checking year types (see below).
 .Pp
 Input lines are made up of fields.
-Fields are separated from one another by any number of white space characters.
+Fields are separated from one another by one or more white space characters.
 Leading and trailing white space on input lines is ignored.
 An unquoted sharp character (#) in the input introduces a comment which extends
 to the end of the line the sharp character appears on.
 White space characters and sharp characters may be enclosed in double
 quotes
 .Pq \&"
 .\" XXX "
 if they're to be used as part of a field.
 Any line that is blank (after comment stripping) is ignored.
 Non-blank lines are expected to be of one of three types:
 rule lines, zone lines, and link lines.
 .Pp
 Names (such as month names) must be in English and are case insensitive.
 @@ -225,55 +246,55 @@ the variable part is null.
 .Pp
 A zone line has the form
 .sp
 .Dl Zone	NAME			GMTOFF	RULES/SAVE	FORMAT	[UNTILYEAR [MONTH [DAY [TIME]]]]
 For example:
 .Dl Zone	Australia/Adelaide	9:30	Aus	CST	1971 Oct 31 2:00
 The fields that make up a zone line are:
 .Bl -tag -width "RULES/SAVE" -compact
 .It NAME
 The name of the time zone.
 This is the name used in creating the time conversion information file for the
 zone.
 .It GMTOFF
-The amount of time to add to UTC to get standard time in this zone.
+The amount of time to add to UT to get standard time in this zone.
 This field has the same format as the
 .Em AT
 and
 .Em SAVE
 fields of rule lines;
-begin the field with a minus sign if time must be subtracted from UTC.
+begin the field with a minus sign if time must be subtracted from UT.
 .It RULES/SAVE
 The name of the rule(s) that apply in the time zone or,
 alternatively, an amount of time to add to local standard time.
 If this field is
 .Em \&-
 then standard time always applies in the time zone.
 .It FORMAT
 The format for time zone abbreviations in this time zone.
 The pair of characters
 .Em %s
 is used to show where the
 .Dq variable part
 of the time zone abbreviation goes.
 Alternatively,
 a slash
 .Pq \&/
 separates standard and daylight abbreviations.
 .It UNTILYEAR [MONTH [DAY [TIME]]]
-The time at which the UTC offset or the rule(s) change for a location.
+The time at which the UT offset or the rule(s) change for a location.
 It is specified as a year, a month, a day, and a time of day.
 If this is specified,
-the time zone information is generated from the given UTC offset
+the time zone information is generated from the given UT offset
 and rule change until the time specified.
 The month, day, and time of day have the same format as the IN, ON, and AT
 fields of a rule; trailing fields can be omitted, and default to the
 earliest possible value for the missing fields.
 .El
 The next line must be a
 .Dq continuation
 line; this has the same form as a zone line except that the
 string
 .Dq Zone
 and the name are omitted, as the continuation line will
 place information starting at the time specified as the
 .Em until
 @@ -288,26 +309,29 @@ A link line has the form
 For example:
 .Dl Link	Europe/Istanbul	Asia/Istanbul
 The
 .Em LINK-FROM
 field should appear as the
 .Em NAME
 field in some zone line;
 the
 .Em LINK-TO
 field is used as an alternative name for that zone.
 .Pp
 Except for continuation lines,
 lines may appear in any order in the input.
 However, the behavior is unspecified if multiple zone or link lines
 define the same name, or if the source of one link line is the target
 of another.
 .Pp
 Lines in the file that describes leap seconds have the following form:
 .Dl Leap	YEAR	MONTH	DAY	HH:MM:SS	CORR	R/S
 For example:
 .Dl Leap	1974	Dec	31	23:59:60	+	S
 The
 .Em YEAR ,
 .Em MONTH ,
 .Em DAY ,
 and
 .Em HH:MM:SS
 fields tell when the leap second happened.
 The
 @@ -338,91 +362,88 @@ should be (an abbreviation of)
 if the leap second time given by the other fields should be interpreted as UTC
 or
 (an abbreviation of)
 .Dq Rolling
 if the leap second time given by the other fields should be interpreted as
 local wall clock time.
 .El
 .Sh EXTENDED EXAMPLE
 Here is an extended example of
 .Ic zic
 input, intended to illustrate many of its features.
 .Bl -column -compact "# Rule" "Swiss" "FROM" "1995" "TYPE" "Oct" "lastSun" "1:00u" "SAVE" "LETTER/S"
 .It # Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
-.It Rule	Swiss	1940	only	-	Nov	2	0:00	1:00	S
+.It Rule	Swiss	1941	1942	-	May	Mon>=1	1:00	1:00	S
-.It Rule	Swiss	1940	only	-	Dec	31	0:00	0	-
+.It Rule	Swiss	1941	1942	-	Oct	Mon>=1	2:00	0	-
 .It Rule	Swiss	1941	1942	-	May	Sun>=1	2:00	1:00	S
 .It Rule	Swiss	1941	1942	-	Oct	Sun>=1	0:00	0
 .Pp
 .It Rule	EU	1977	1980	-	Apr	Sun>=1	1:00u	1:00	S
 .It Rule	EU	1977	only	-	Sep	lastSun	1:00u	0	-
 .It Rule	EU	1978	only	-	Oct	 1	1:00u	0	-
 .It Rule	EU	1979	1995	-	Sep	lastSun	1:00u	0	-
 .It Rule	EU	1981	max	-	Mar	lastSun	1:00u	1:00	S
 .It Rule	EU	1996	max	-	Oct	lastSun	1:00u	0	-
 .El
 .Pp
-.Bl -column -compact "# Zone" "Europe/Zurich" "0:29:44" "RULES" "FORMAT" "UNTIL"
+.Bl -column -compact "# Zone" "Europe/Zurich" "0:34:08" "RULES/SAVE" "FORMAT" "UNTIL"
-.It # Zone	NAME	GMTOFF	RULES	FORMAT	UNTIL
+.It # Zone	NAME	GMTOFF	RULES/SAVE	FORMAT	UNTIL
-.It Zone	Europe/Zurich	0:34:08	-	LMT	1848 Sep 12
+.It Zone	Europe/Zurich	0:34:08	-	LMT	1853 Jul 16
 .It 		0:29:44	-	BMT	1894 Jun
 .It 		1:00	Swiss	CE%sT	1981
 .It 		1:00	EU	CE%sT
 .It Link	Europe/Zurich	Switzerland
 .El
 .Pp
 In this example, the zone is named Europe/Zurich but it has an alias
 as Switzerland.
-Zurich was 34 minutes and 8 seconds west of GMT until
+This example says that Zurich was 34 minutes and 8
--09-12 at 00:00, when the offset changed to 29 minutes and 44
+seconds west of UT until 1853-07-16 at 00:00, when the legal offset
-seconds.
+was changed to 7\(de\|26\(fm\|22.50\(sd; although this works out to
-After 1894-06-01 at 00:00 Swiss daylight saving rules (defined
+:29:45.50, the input format cannot represent fractional seconds so it
-with lines beginning with "Rule Swiss") apply, and the GMT offset
+is rounded here.
 After 1894-06-01 at 00:00 Swiss daylight saving rules
 (defined with lines beginning with "Rule Swiss") apply, and the UT offset
 became one hour.
 From 1981 to the present, EU daylight saving rules have
 applied, and the UTC offset has remained at one hour.
 .Pp
-In 1940, daylight saving time applied from November 2 at 00:00 to
+In 1941 and 1942, daylight saving time applied from the first Monday
-December 31 at 00:00.
+in May at 01:00 to the first Monday in October at 02:00.
 In 1941 and 1942, daylight saving time applied
 from the first Sunday in May at 02:00 to the first Sunday in October
 at 00:00.
 The pre-1981 EU daylight-saving rules have no effect
 here, but are included for completeness.
 Since 1981, daylight
 saving has begun on the last Sunday in March at 01:00 UTC.
 Until 1995 it ended the last Sunday in September at 01:00 UTC,
 but this changed to the last Sunday in October starting in 1996.
 .Pp
 For purposes of
 display, "LMT" and "BMT" were initially used, respectively.
 Since
 Swiss rules and later EU rules were applied, the display name for the
 timezone has been CET for standard time and CEST for daylight saving
 time.
 .Sh NOTES
 For areas with more than two types of local time,
 you may need to use local standard time in the
 .Em AT
 field of the earliest transition time's rule to ensure that
 the earliest transition time recorded in the compiled file is correct.
 .Pp
 If,
 for a particular zone,
 a clock advance caused by the start of daylight saving
 coincides with and is equal to
-a clock retreat caused by a change in UTC offset,
+a clock retreat caused by a change in UT offset,
 .Ic zic
-produces a single transition to daylight saving at the new UTC offset
+produces a single transition to daylight saving at the new UT offset
 (without any change in wall clock time).
 To get separate transitions
 use multiple zone continuation lines
 specifying transition instants using universal time.
 .Sh FILES
 .Pa /usr/share/zoneinfo
 - standard directory used for created files
 .Sh SEE ALSO
 .Xr ctime 3 ,
 .Xr tzfile 5 ,
 .Xr zdump 8
 .\" @(#)zic.8	8.6
 .\" This file is in the public domain, so clarified as of

--- src/lib/libc/time/zic.c 2013/08/06 05:48:39	1.42
+++ src/lib/libc/time/zic.c 2013/09/20 19:06:54	1.43

 @@ -1,55 +1,57 @@
-/*	$NetBSD: zic.c,v 1.42 2013/08/06 05:48:39 christos Exp $	*/
+/*	$NetBSD: zic.c,v 1.43 2013/09/20 19:06:54 christos 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.42 2013/08/06 05:48:39 christos Exp $");
+__RCSID("$NetBSD: zic.c,v 1.43 2013/09/20 19:06:54 christos Exp $");
 #endif /* !defined lint */
 #include "version.h"
 #include "private.h"
 #include "locale.h"
 #include "tzfile.h"
-#define	ZIC_VERSION	'2'
+#include <stdarg.h>
 #include <unistd.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 */
 #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
 #include "unistd.h"
 /*
 ** On some ancient hosts, predicates like `isspace(C)' are defined
 ** only if isascii(C) || C == EOF. Modern hosts obey the C Standard,
 ** which says they are defined only if C == ((unsigned char) C) || C == EOF.
 ** Neither the C Standard nor Posix require that `isascii' exist.
 ** For portability, we check both ancient and modern requirements.
 ** If isascii is not defined, the isascii check succeeds trivially.
 */
 #include "ctype.h"
 #ifndef isascii
 #define isascii(x) 1
 #endif
 @@ -125,27 +127,26 @@ static void	associate(void);
 static void	dolink(const char * fromfield, const char * tofield);
 static char **	getfields(char * buf);
 static zic_t	gethms(const char * string, const char * errstrng,
 			int signable);
 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 int	inzcont(char ** fields, int nfields);
 static int	inzone(char ** fields, int nfields);
 static int	inzsub(char ** fields, int nfields, int iscont);
 static int	itsdir(const char * name);
 static int	lowerit(int c);
 int		main(int, char **);
 static int	mkdirs(char * filename);
 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 int	rcomp(const void * leftp, const void * rightp);
 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 int	yearistype(int year, const char * type);
 static int	atcomp(const void *avp, const void *bvp);
 @@ -395,52 +396,60 @@ eats(const char *const name, const int n
+{
 	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
+static void ATTRIBUTE_FORMAT((printf, 1, 0))
-error(const char *const string)
+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.
 	*/
-	(void) fprintf(stderr, _("\"%s\", line %d: %s"),
+	fprintf(stderr, _("\"%s\", line %d: "), filename, linenum);
-		filename, linenum, string);
+	vfprintf(stderr, string, args);
 	if (rfilename != NULL)
 		(void) fprintf(stderr, _(" (rule from \"%s\", line %d)"),
 			rfilename, rlinenum);
 	(void) fprintf(stderr, "\n");
 	++errors;
+}
-static void
+static void ATTRIBUTE_FORMAT((printf, 1, 2))
-warning(const char *const string)
+error(const char *const string, ...)
+{
-	char *	cp;
+	va_list args;
 	va_start(args, string);
-	cp = ecpyalloc(_("warning: "));
+	verror(string, args);
-	cp = ecatalloc(cp, string);
+	va_end(args);
 	error(cp);
 	free(cp);
 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);
 	--errors;
+}
 static _Noreturn void
 usage(FILE *stream, int status)
+{
 	(void) fprintf(stream, _("%s: usage is %s \
 [ --version ] [ --help ] [ -v ] [ -l localtime ] [ -p posixrules ] \\\n\
 \t[ -d directory ] [ -L leapseconds ] [ -y yearistype ] [ filename ... ]\n\
 \n\
 Report bugs to %s.\n"),
 		       progname, progname, REPORT_BUGS_TO);
 	exit(status);
 @@ -749,27 +758,27 @@ associate(void)
 		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 (strchr(zp->z_format, '%') != 0)
-				error(_("%s in ruleless zone"));
+				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;
 @@ -879,33 +888,33 @@ gethms(const char *string, const char *c
 		return 0;
 	if (!signable)
 		sign = 1;
 	else if (*string == '-') {
 		sign = -1;
 		++string;
 	} else	sign = 1;
 	if (sscanf(string, scheck(string, "%"SCNdZIC), &hh) == 1)
 		mm = ss = 0;
 	else if (sscanf(string, scheck(string, "%"SCNdZIC":%d"), &hh, &mm) == 2)
 		ss = 0;
 	else if (sscanf(string, scheck(string, "%"SCNdZIC":%d:%d"),
 		&hh, &mm, &ss) != 3) {
-			error(errstring);
+			error("%s", errstring);
 			return 0;
+	}
 	if (hh < 0 ||
 		mm < 0 || mm >= MINSPERHOUR ||
 		ss < 0 || ss > SECSPERMIN) {
-			error(errstring);
+			error("%s", errstring);
 			return 0;
+	}
 	if (ZIC_MAX / SECSPERHOUR < hh) {
 		error(_("time overflow"));
 		return 0;
+	}
 	if (noise && hh == HOURSPERDAY && mm == 0 && ss == 0)
 		warning(_("24:00 not handled by pre-1998 versions of zic"));
 	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));
 @@ -931,60 +940,51 @@ inrule(char **const fields, const int nf
 		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 = erealloc(rules, (nrules + 1) * sizeof *rules);
 	rules[nrules++] = r;
+}
 static int
 inzone(char **const fields, const int nfields)
+{
 	int	i;
 	static char *	buf;
 	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) {
-		buf = erealloc(buf, 132 + strlen(TZDEFAULT));
+		error(
 		(void)sprintf(buf,	/* XXX: sprintf is safe */
 _("\"Zone %s\" line and -l option are mutually exclusive"),
 			TZDEFAULT);
 		error(buf);
 		return FALSE;
+	}
 	if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL) {
-		buf = erealloc(buf, 132 + strlen(TZDEFRULES));
+		error(
 		(void)sprintf(buf,	/* XXX: sprintf is safe */
 _("\"Zone %s\" line and -p option are mutually exclusive"),
 			TZDEFRULES);
 		error(buf);
 		return FALSE;
+	}
 	for (i = 0; i < nzones; ++i)
 		if (zones[i].z_name != NULL &&
 			strcmp(zones[i].z_name, fields[ZF_NAME]) == 0) {
-				buf = erealloc(buf, 132 +
+			error(
 					strlen(fields[ZF_NAME]) +
 					strlen(zones[i].z_filename));
 				(void)sprintf(buf,	/* XXX: sprintf is safe */
 _("duplicate zone name %s (file \"%s\", line %d)"),
 					fields[ZF_NAME],
 					zones[i].z_filename,
 					zones[i].z_linenum);
 				error(buf);
 				return FALSE;
+		}
 	return inzsub(fields, nfields, FALSE);
+}
 static int
 inzcont(char **const fields, const 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);
 @@ -1011,27 +1011,27 @@ inzsub(char **const fields, const int nf
 		z.z_name = NULL;
 	} 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 UTC offset"), TRUE);
+	z.z_gmtoff = gethms(fields[i_gmtoff], _("invalid UT offset"), TRUE);
 	if ((cp = strchr(fields[i_format], '%')) != 0) {
 		if (*++cp != 's' || strchr(cp, '%') != 0) {
 			error(_("invalid abbreviation format"));
 			return FALSE;
+		}
+	}
 	z.z_rule = ecpyalloc(fields[i_rule]);
 	z.z_format = ecpyalloc(fields[i_format]);
 	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;
 @@ -1387,27 +1387,27 @@ 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 int
 is32(const zic_t x)
+{
 	return INT32_MIN <= x && x <= INT32_MAX;
+}
 static void
-writezone(const char *const name, const char *const string)
+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 char *			fullname;
 	static const struct tzhead	tzh0;
 	static struct tzhead		tzh;
 	zic_t				ats[TZ_MAX_TIMES];
 	unsigned char			types[TZ_MAX_TIMES];
 	/*
 @@ -1645,27 +1645,27 @@ writezone(const char *const name, const
 				if (strcmp(&thischars[j], thisabbr) == 0)
 					break;
 			if (j == thischarcnt) {
 				(void) strcpy(&thischars[(int) thischarcnt],
 					thisabbr);
 				thischarcnt += strlen(thisabbr) + 1;
+			}
 			indmap[abbrinds[i]] = j;
+		}
 #define DO(field)	(void) fwrite(tzh.field, \
 				sizeof tzh.field, (size_t) 1, fp)
 		tzh = tzh0;
 		(void) strncpy(tzh.tzh_magic, TZ_MAGIC, sizeof tzh.tzh_magic);
-		tzh.tzh_version[0] = ZIC_VERSION;
+		tzh.tzh_version[0] = version;
 		convert(thistypecnt, tzh.tzh_ttisgmtcnt);
 		convert(thistypecnt, tzh.tzh_ttisstdcnt);
 		convert(thisleapcnt, tzh.tzh_leapcnt);
 		convert(thistimecnt, tzh.tzh_timecnt);
 		convert(thistypecnt, tzh.tzh_typecnt);
 		convert(thischarcnt, tzh.tzh_charcnt);
 		DO(tzh_magic);
 		DO(tzh_version);
 		DO(tzh_reserved);
 		DO(tzh_ttisgmtcnt);
 		DO(tzh_ttisstdcnt);
 		DO(tzh_leapcnt);
 		DO(tzh_timecnt);
 @@ -1783,196 +1783,261 @@ stringoffset(char *result, zic_t offset)
 	int	minutes;
 	int	seconds;
 	result[0] = '\0';
 	if (offset < 0) {
 		(void) strcpy(result, "-");
 		offset = -offset;
+	}
 	seconds = offset % SECSPERMIN;
 	offset /= SECSPERMIN;
 	minutes = offset % MINSPERHOUR;
 	offset /= MINSPERHOUR;
 	hours = offset;
-	if (hours > HOURSPERDAY) {
+	if (hours >= HOURSPERDAY * DAYSPERWEEK) {
 		result[0] = '\0';
 		return -1;
+	}
 	(void) sprintf(end(result), "%d", hours);
 	if (minutes != 0 || seconds != 0) {
 		(void) sprintf(end(result), ":%02d", minutes);
 		if (seconds != 0)
 			(void) sprintf(end(result), ":%02d", seconds);
+	}
 	return 0;
+}
 static int
 stringrule(char *result, const struct rule *const rp, const zic_t dstoff,
     const zic_t gmtoff)
+{
-	zic_t	tod;
+	zic_t	tod = rp->r_tod;
 	int	compat = 0;
 	result = end(result);
 	if (rp->r_dycode == DC_DOM) {
 		int	month, total;
 		if (rp->r_dayofmonth == 29 && rp->r_month == TM_FEBRUARY)
 			return -1;
 		total = 0;
 		for (month = 0; month < rp->r_month; ++month)
 			total += len_months[0][month];
-		(void) sprintf(result, "J%d", total + rp->r_dayofmonth);
+		/* Omit the "J" in Jan and Feb, as that's shorter.  */
 		if (rp->r_month <= 1)
 		  (void) sprintf(result, "%d", total + rp->r_dayofmonth - 1);
 		else
 		  (void) sprintf(result, "J%d", total + rp->r_dayofmonth);
 	} else {
 		int	week;
 		int	wday = rp->r_wday;
 		int	wdayoff;
 		if (rp->r_dycode == DC_DOWGEQ) {
-			if ((rp->r_dayofmonth % DAYSPERWEEK) != 1)
+			wdayoff = (rp->r_dayofmonth - 1) % DAYSPERWEEK;
-				return -1;
+			if (wdayoff)
-			week = 1 + rp->r_dayofmonth / DAYSPERWEEK;
+				compat = 2013;
 			wday -= wdayoff;
 			tod += wdayoff * SECSPERDAY;
 			week = 1 + (rp->r_dayofmonth - 1) / DAYSPERWEEK;
 		} else if (rp->r_dycode == DC_DOWLEQ) {
 			if (rp->r_dayofmonth == len_months[1][rp->r_month])
 				week = 5;
 			else {
-				if ((rp->r_dayofmonth % DAYSPERWEEK) != 0)
+				wdayoff = rp->r_dayofmonth % DAYSPERWEEK;
-					return -1;
+				if (wdayoff)
 					compat = 2013;
 				wday -= wdayoff;
 				tod += wdayoff * SECSPERDAY;
 				week = rp->r_dayofmonth / DAYSPERWEEK;
+			}
 		} else	return -1;	/* "cannot happen" */
 		if (wday < 0)
 			wday += DAYSPERWEEK;
 		(void) sprintf(result, "M%d.%d.%d",
-			rp->r_month + 1, week, rp->r_wday);
+			rp->r_month + 1, week, wday);
+	}
 	tod = rp->r_tod;
 	if (rp->r_todisgmt)
 		tod += gmtoff;
 	if (rp->r_todisstd && rp->r_stdoff == 0)
 		tod += dstoff;
 	if (tod < 0) {
 		result[0] = '\0';
 		return -1;
 	if (tod != 2 * SECSPERMIN * MINSPERHOUR) {
 		(void) strcat(result, "/");
 		if (stringoffset(end(result), tod) != 0)
 			return -1;
 		if (tod < 0) {
 			if (compat < 2013)
 				compat = 2013;
 		} else if (SECSPERDAY <= tod) {
 			if (compat < 1994)
 				compat = 1994;
+		}
+	}
-	return 0;
+	return compat;
+}
-static void
+static int
 rule_cmp(struct rule const *a, struct rule const *b)
+{
 	if (!a)
 		return -!!b;
 	if (!b)
 		return 1;
 	if (a->r_hiyear != b->r_hiyear)
 		return a->r_hiyear < b->r_hiyear ? -1 : 1;
 	if (a->r_month - b->r_month != 0)
 		return a->r_month - b->r_month;
 	return a->r_dayofmonth - b->r_dayofmonth;
+}
 enum { YEAR_BY_YEAR_ZONE = 1 };
 static int
 stringzone(char *result, const int resultlen, const struct zone *const zpfirst,
     const int zonecount)
+{
 	const struct zone *	zp;
 	struct rule *		rp;
 	struct rule *		stdrp;
 	struct rule *		dstrp;
 	int			i;
 	const char *		abbrvar;
 	int			compat = 0;
 	int			c;
 	struct rule		stdr, dstr;
 	result[0] = '\0';
 	zp = zpfirst + zonecount - 1;
 	stdrp = dstrp = NULL;
 	for (i = 0; i < zp->z_nrules; ++i) {
 		rp = &zp->z_rules[i];
 		if (rp->r_hiwasnum || rp->r_hiyear != ZIC_MAX)
 			continue;
 		if (rp->r_yrtype != NULL)
 			continue;
 		if (rp->r_stdoff == 0) {
 			if (stdrp == NULL)
 				stdrp = rp;
-			else	return;
+			else	return -1;
 		} else {
 			if (dstrp == NULL)
 				dstrp = rp;
-			else	return;
+			else	return -1;
+		}
+	}
 	if (stdrp == NULL && dstrp == NULL) {
 		/*
 		** There are no rules running through "max".
-		** Let's find the latest rule.
+		** Find the latest std rule in stdabbrrp
 		** and latest rule of any type in stdrp.
 		*/
 		struct rule *stdabbrrp = NULL;
 		for (i = 0; i < zp->z_nrules; ++i) {
 			rp = &zp->z_rules[i];
-			if (stdrp == NULL || rp->r_hiyear > stdrp->r_hiyear ||
+			if (rp->r_stdoff == 0 && rule_cmp(stdabbrrp, rp) < 0)
-				(rp->r_hiyear == stdrp->r_hiyear &&
+				stdabbrrp = rp;
-				(rp->r_month > stdrp->r_month ||
+			if (rule_cmp(stdrp, rp) < 0)
-				(rp->r_month == stdrp->r_month &&
+				stdrp = rp;
 				rp->r_dayofmonth > stdrp->r_dayofmonth))))
 					stdrp = rp;
+		}
 		if (stdrp != NULL && stdrp->r_stdoff != 0)
 			return;	/* We end up in DST (a POSIX no-no). */
 		/*
 		** Horrid special case: if year is 2037,
 		** presume this is a zone handled on a year-by-year basis;
 		** do not try to apply a rule to the zone.
 		*/
 		if (stdrp != NULL && stdrp->r_hiyear == 2037)
-			return;
+			return YEAR_BY_YEAR_ZONE;
 		if (stdrp != NULL && stdrp->r_stdoff != 0) {
 			/* Perpetual DST.  */
 			dstr.r_month = TM_JANUARY;
 			dstr.r_dycode = DC_DOM;
 			dstr.r_dayofmonth = 1;
 			dstr.r_tod = 0;
 			dstr.r_todisstd = dstr.r_todisgmt = FALSE;
 			dstr.r_stdoff = stdrp->r_stdoff;
 			dstr.r_abbrvar = stdrp->r_abbrvar;
 			stdr.r_month = TM_DECEMBER;
 			stdr.r_dycode = DC_DOM;
 			stdr.r_dayofmonth = 31;
 			stdr.r_tod = SECSPERDAY + stdrp->r_stdoff;
 			stdr.r_todisstd = stdr.r_todisgmt = FALSE;
 			stdr.r_stdoff = 0;
 			stdr.r_abbrvar
 			  = (stdabbrrp ? stdabbrrp->r_abbrvar : "");
 			dstrp = &dstr;
 			stdrp = &stdr;
+		}
+	}
 	if (stdrp == NULL && (zp->z_nrules != 0 || zp->z_stdoff != 0))
-		return;
+		return -1;
 	abbrvar = (stdrp == NULL) ? "" : stdrp->r_abbrvar;
 	doabbr(result, resultlen, zp->z_format, abbrvar, FALSE, TRUE);
 	if (stringoffset(end(result), -zp->z_gmtoff) != 0) {
 		result[0] = '\0';
-		return;
+		return -1;
+	}
 	if (dstrp == NULL)
-		return;
+		return compat;
 	doabbr(end(result), resultlen - strlen(result),
 		zp->z_format, dstrp->r_abbrvar, TRUE, TRUE);
 	if (dstrp->r_stdoff != SECSPERMIN * MINSPERHOUR)
 		if (stringoffset(end(result),
 			-(zp->z_gmtoff + dstrp->r_stdoff)) != 0) {
 				result[0] = '\0';
-				return;
+				return -1;
+		}
 	(void) strcat(result, ",");
-	if (stringrule(result, dstrp, dstrp->r_stdoff, zp->z_gmtoff) != 0) {
+	c = stringrule(result, dstrp, dstrp->r_stdoff, zp->z_gmtoff);
 	if (c < 0) {
 		result[0] = '\0';
-		return;
+		return -1;
+	}
 	if (compat < c)
 		compat = c;
 	(void) strcat(result, ",");
-	if (stringrule(result, stdrp, dstrp->r_stdoff, zp->z_gmtoff) != 0) {
+	c = stringrule(result, stdrp, dstrp->r_stdoff, zp->z_gmtoff);
 	if (c < 0) {
 		result[0] = '\0';
-		return;
+		return -1;
+	}
 	if (compat < c)
 		compat = c;
 	return compat;
+}
 static void
 outzone(const struct zone *const zpfirst, const int zonecount)
+{
 	const struct zone *	zp;
 	struct rule *		rp;
 	int			i, j;
 	int			usestart, useuntil;
 	zic_t			starttime, untiltime;
 	zic_t			gmtoff;
 	zic_t			stdoff;
 	zic_t			year;
 	zic_t			startoff;
 	int			startttisstd;
 	int			startttisgmt;
 	int			type;
 	char *			startbuf;
 	char *			ab;
 	char *			envvar;
 	size_t			max_abbr_len;
 	size_t			max_envvar_len;
 	int			prodstic; /* all rules are min to max */
 	int			compat;
 	int			do_extend;
 	int			version;
 	max_abbr_len = 2 + max_format_len + max_abbrvar_len;
 	max_envvar_len = 2 * max_abbr_len + 5 * 9;
 	startbuf = emalloc(max_abbr_len + 1);
 	ab = emalloc(max_abbr_len + 1);
 	envvar = emalloc(max_envvar_len + 1);
 	INITIALIZE(untiltime);
 	INITIALIZE(starttime);
 	/*
 	** Now. . .finally. . .generate some useful data!
 	*/
 	timecnt = 0;
 	typecnt = 0;
 @@ -2001,52 +2066,74 @@ outzone(const struct zone *const zpfirst
 		for (j = 0; j < zp->z_nrules; ++j) {
 			rp = &zp->z_rules[j];
 			if (rp->r_lowasnum)
 				updateminmax(rp->r_loyear);
 			if (rp->r_hiwasnum)
 				updateminmax(rp->r_hiyear);
 			if (rp->r_lowasnum || rp->r_hiwasnum)
 				prodstic = FALSE;
+		}
+	}
 	/*
 	** Generate lots of data if a rule can't cover all future times.
 	*/
-	stringzone(envvar, max_envvar_len+1, zpfirst, zonecount);
+	compat = stringzone(envvar, max_envvar_len + 1, zpfirst, zonecount);
-	if (noise && envvar[0] == '\0') {
+	version = compat < 2013 ? ZIC_VERSION_PRE_2013 : ZIC_VERSION;
-		char *	wp;
+	do_extend = compat < 0 || compat == YEAR_BY_YEAR_ZONE;
 	if (noise && compat != 0 && compat != YEAR_BY_YEAR_ZONE) {
-		wp = ecpyalloc(_("no POSIX environment variable for zone"));
+		if (compat < 0)
-		wp = ecatalloc(wp, " ");
+			warning("%s %s",
-		wp = ecatalloc(wp, zpfirst->z_name);
+				_("no POSIX environment variable for zone"),
-		warning(wp);
+				zpfirst->z_name);
-		free(wp);
+		else {
 			/* Circa-COMPAT clients, and earlier clients, might
-	if (envvar[0] == '\0') {
+			   not work for this zone when given dates before
-		if (min_year >= ZIC_MIN + YEARSPERREPEAT)
+or after 2038.  */
-			min_year -= YEARSPERREPEAT;
+			warning(_("%s: pre-%d clients may mishandle"
 				  " distant timestamps"),
 				zpfirst->z_name, compat);
+		}
+	}
 	if (do_extend) {
 		/*
 		** Search through a couple of extra years past the obvious
 		** 400, to avoid edge cases.  For example, suppose a non-POSIX
 		** rule applies from 2012 onwards and has transitions in March
 		** and September, plus some one-off transitions in November
 		** 2013.  If zic looked only at the last 400 years, it would
 		** set max_year=2413, with the intent that the 400 years 2014
 		** through 2413 will be repeated.  The last transition listed
 		** in the tzfile would be in 2413-09, less than 400 years
 		** after the last one-off transition in 2013-11.  Two years
 		** might be overkill, but with the kind of edge cases
 		** available we're not sure that one year would suffice.
 		*/
 		enum { years_of_observations = YEARSPERREPEAT + 2 };
 		if (min_year >= ZIC_MIN + years_of_observations)
 			min_year -= years_of_observations;
 		else	min_year = ZIC_MIN;
-		if (max_year <= ZIC_MAX - YEARSPERREPEAT)
+		if (max_year <= ZIC_MAX - years_of_observations)
-			max_year += YEARSPERREPEAT;
+			max_year += years_of_observations;
 		else	max_year = ZIC_MAX;
 		/*
 		** Regardless of any of the above,
 		** for a "proDSTic" zone which specifies that its rules
 		** always have and always will be in effect,
 		** we only need one cycle to define the zone.
 		*/
 		if (prodstic) {
 			min_year = 1900;
-			max_year = min_year + YEARSPERREPEAT;
+			max_year = min_year + years_of_observations;
+		}
+	}
 	/*
 	** For the benefit of older systems,
 	** generate data from 1900 through 2037.
 	*/
 	if (min_year > 1900)
 		min_year = 1900;
 	if (max_year < 2037)
 		max_year = 2037;
 	for (i = 0; i < zonecount; ++i) {
 		/*
 		** A guess that may well be corrected later.
 @@ -2088,27 +2175,27 @@ outzone(const struct zone *const zpfirst
 						year <= rp->r_hiyear &&
 						yearistype(year, rp->r_yrtype);
 				if (rp->r_todo)
 					rp->r_temp = rpytime(rp, year);
+			}
 			for ( ; ; ) {
 				int	k;
 				zic_t	jtime, ktime;
 				zic_t	offset;
 				INITIALIZE(ktime);
 				if (useuntil) {
 					/*
-					** Turn untiltime into UTC
+					** Turn untiltime into UT
 					** assuming the current gmtoff and
 					** stdoff values.
 					*/
 					untiltime = zp->z_untiltime;
 					if (!zp->z_untilrule.r_todisgmt)
 						untiltime = tadd(untiltime,
 							-gmtoff);
 					if (!zp->z_untilrule.r_todisstd)
 						untiltime = tadd(untiltime,
 							-stdoff);
+				}
 				/*
 				** Find the rule (of those to do, if any)
 @@ -2196,27 +2283,65 @@ error(_("can't determine time zone abbre
 		/*
 		** Now we may get to set starttime for the next zone line.
 		*/
 		if (useuntil) {
 			startttisstd = zp->z_untilrule.r_todisstd;
 			startttisgmt = zp->z_untilrule.r_todisgmt;
 			starttime = zp->z_untiltime;
 			if (!startttisstd)
 				starttime = tadd(starttime, -stdoff);
 			if (!startttisgmt)
 				starttime = tadd(starttime, -gmtoff);
+		}
+	}
-	writezone(zpfirst->z_name, envvar);
+	if (do_extend) {
 		/*
 		** If we're extending the explicitly listed observations
 		** for 400 years because we can't fill the POSIX-TZ field,
 		** check whether we actually ended up explicitly listing
 		** observations through that period.  If there aren't any
 		** near the end of the 400-year period, add a redundant
 		** one at the end of the final year, to make it clear
 		** that we are claiming to have definite knowledge of
 		** the lack of transitions up to that point.
 		*/
 		struct rule xr;
 		struct attype *lastat;
 		xr.r_month = TM_JANUARY;
 		xr.r_dycode = DC_DOM;
 		xr.r_dayofmonth = 1;
 		xr.r_tod = 0;
 		for (lastat = &attypes[0], i = 1; i < timecnt; i++)
 			if (attypes[i].at > lastat->at)
 				lastat = &attypes[i];
 		if (lastat->at < rpytime(&xr, max_year - 1)) {
 			/*
 			** Create new type code for the redundant entry,
 			** to prevent it being optimised away.
 			*/
 			if (typecnt >= TZ_MAX_TYPES) {
 				error(_("too many local time types"));
 				exit(EXIT_FAILURE);
+			}
 			gmtoffs[typecnt] = gmtoffs[lastat->type];
 			isdsts[typecnt] = isdsts[lastat->type];
 			ttisstds[typecnt] = ttisstds[lastat->type];
 			ttisgmts[typecnt] = ttisgmts[lastat->type];
 			abbrinds[typecnt] = abbrinds[lastat->type];
 			++typecnt;
 			addtt(rpytime(&xr, max_year + 1), typecnt-1);
+		}
+	}
 	writezone(zpfirst->z_name, envvar, version);
 	free(startbuf);
 	free(ab);
 	free(envvar);
+}
 static void
 addtt(const zic_t starttime, int type)
+{
 	if (starttime <= min_time ||
 		(timecnt == 1 && attypes[0].at < min_time)) {
 		gmtoffs[0] = gmtoffs[type];
 		isdsts[0] = isdsts[type];
 		ttisstds[0] = ttisstds[type];
 @@ -2266,27 +2391,27 @@ addtype(const zic_t gmtoff, const char *
 			ttisstd == ttisstds[i] &&
 			ttisgmt == ttisgmts[i])
 				return i;
+	}
 	/*
 	** There isn't one; add a new one, unless there are already too
 	** many.
 	*/
 	if (typecnt >= TZ_MAX_TYPES) {
 		error(_("too many local time types"));
 		exit(EXIT_FAILURE);
+	}
 	if (! (-1L - 2147483647L <= gmtoff && gmtoff <= 2147483647L)) {
-		error(_("UTC offset out of range"));
+		error(_("UT offset out of range"));
 		exit(EXIT_FAILURE);
+	}
 	gmtoffs[i] = gmtoff;
 	isdsts[i] = isdst;
 	ttisstds[i] = ttisstd;
 	ttisgmts[i] = ttisgmt;
 	for (j = 0; j < charcnt; ++j)
 		if (strcmp(&chars[j], abbr) == 0)
 			break;
 	if (j == charcnt)
 		newabbr(abbr);
 	abbrinds[i] = j;
 @@ -2461,27 +2586,27 @@ getfields(char *cp)
 	return array;
+}
 static ATTRIBUTE_PURE zic_t
 oadd(const zic_t t1, const zic_t t2)
+{
 	if (t1 < 0 ? t2 < ZIC_MIN - t1 : ZIC_MAX - t1 < t2) {
 		error(_("time overflow"));
 		exit(EXIT_FAILURE);
+	}
 	return t1 + t2;
+}
-static zic_t
+static ATTRIBUTE_PURE zic_t
 tadd(const zic_t t1, const zic_t t2)
+{
 	if (t1 == max_time && t2 > 0)
 		return max_time;
 	if (t1 == min_time && t2 < 0)
 		return min_time;
 	if (t1 < 0 ? t2 < min_time - t1 : max_time - t1 < t2) {
 		error(_("time overflow"));
 		exit(EXIT_FAILURE);
+	}
 	return t1 + t2;
+}
 @@ -2595,34 +2720,28 @@ mp = _("time zone abbreviation lacks alp
 mp = _("time zone abbreviation has fewer than 3 alphabetics");
 		if (cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
 mp = _("time zone abbreviation has too many alphabetics");
 		if (mp == NULL && (*cp == '+' || *cp == '-')) {
 			++cp;
 			if (isascii((unsigned char) *cp) &&
 				isdigit((unsigned char) *cp))
 					if (*cp++ == '1' &&
 						*cp >= '0' && *cp <= '4')
 							++cp;
+		}
 		if (*cp != '\0')
 mp = _("time zone abbreviation differs from POSIX standard");
-		if (mp != NULL) {
+		if (mp != NULL)
-			char *wp = ecpyalloc(mp);
+			warning("%s (%s)", mp, string);
 			wp = ecatalloc(wp, " (");
 			wp = ecatalloc(wp, string);
 			wp = ecatalloc(wp, ")");
 			warning(wp);
 			free(wp);
+	}
 	i = strlen(string) + 1;
 	if (charcnt + i > TZ_MAX_CHARS) {
 		error(_("too many, or too long, time zone abbreviations"));
 		exit(EXIT_FAILURE);
+	}
 	(void)strncpy(&chars[charcnt], string, sizeof(chars) - charcnt - 1);
 	charcnt += i;
+}
 static int
 mkdirs(char *argname)
+{