zic.c File Reference

#include "postgres_fe.h"
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>
#include "pg_getopt.h"
#include "private.h"
#include "tzfile.h"

Include dependency graph for zic.c:

Go to the source code of this file.

Data Structures
struct	rule
struct	zone
struct	link
struct	lookup
struct	attype
struct	timerange

Macros
#define	ZIC_VERSION_PRE_2013   '2'
#define	ZIC_VERSION   '3'
#define	ZIC_MIN   INT_FAST64_MIN
#define	ZIC_MAX   INT_FAST64_MAX
#define	PRIdZIC   PRIdFAST64
#define	SCNdZIC   SCNdFAST64
#define	ZIC_MAX_ABBR_LEN_WO_WARN   6
#define	MKDIR_UMASK   0755
#define	_Alignof(type)   offsetof(struct { char a; type b; }, b)
#define	DC_DOM   0 /* 1..31 */ /* unused */
#define	DC_DOWGEQ   1 /* 1..31 */ /* 0..6 (Sun..Sat) */
#define	DC_DOWLEQ   2 /* 1..31 */ /* 0..6 (Sun..Sat) */
#define	linkat(targetdir, target, linknamedir, linkname, flag)    (itssymlink(target) ? (errno = ENOTSUP, -1) : link(target, linkname))
#define	LC_RULE   0
#define	LC_ZONE   1
#define	LC_LINK   2
#define	LC_LEAP   3
#define	LC_EXPIRES   4
#define	ZF_NAME   1
#define	ZF_STDOFF   2
#define	ZF_RULE   3
#define	ZF_FORMAT   4
#define	ZF_TILYEAR   5
#define	ZF_TILMONTH   6
#define	ZF_TILDAY   7
#define	ZF_TILTIME   8
#define	ZONE_MINFIELDS   5
#define	ZONE_MAXFIELDS   9
#define	ZFC_STDOFF   0
#define	ZFC_RULE   1
#define	ZFC_FORMAT   2
#define	ZFC_TILYEAR   3
#define	ZFC_TILMONTH   4
#define	ZFC_TILDAY   5
#define	ZFC_TILTIME   6
#define	ZONEC_MINFIELDS   3
#define	ZONEC_MAXFIELDS   7
#define	RF_NAME   1
#define	RF_LOYEAR   2
#define	RF_HIYEAR   3
#define	RF_COMMAND   4
#define	RF_MONTH   5
#define	RF_DAY   6
#define	RF_TOD   7
#define	RF_SAVE   8
#define	RF_ABBRVAR   9
#define	RULE_FIELDS   10
#define	LF_TARGET   1
#define	LF_LINKNAME   2
#define	LINK_FIELDS   3
#define	LP_YEAR   1
#define	LP_MONTH   2
#define	LP_DAY   3
#define	LP_TIME   4
#define	LP_CORR   5
#define	LP_ROLL   6
#define	LEAP_FIELDS   7
#define	EXPIRES_FIELDS   5
#define	YR_MINIMUM   0
#define	YR_MAXIMUM   1
#define	YR_ONLY   2
#define	TIME_T_BITS_IN_FILE   64
#define	ZIC_BLOAT_DEFAULT   "slim"
#define	DO(field)   fwrite(tzh.field, sizeof tzh.field, 1, fp)
#define	LDAYSPERWEEK   ((zic_t) DAYSPERWEEK)

Typedefs
typedef int_fast64_t	zic_t
typedef intmax_t	lineno_t

Enumerations
enum	{ PERCENT_Z_LEN_BOUND = sizeof "+995959" - 1 }
enum	{ WORK_AROUND_QTBUG_53071 = true }

Functions
int	link (const char *target, const char *linkname)
static void	verror (const char *const string, va_list args) pg_attribute_printf(1
static void static void	error (const char *const string,...) pg_attribute_printf(1
static void static void static void	warning (const char *const string,...) pg_attribute_printf(1
static void static void static void static void	addtt (zic_t starttime, int type)
static int	addtype (zic_t utoff, char const *abbr, bool isdst, bool ttisstd, bool ttisut)
static void	leapadd (zic_t t, int correction, int rolling)
static void	adjleap (void)
static void	associate (void)
static void	dolink (const char *target, const char *linkname, bool staysymlink)
static char **	getfields (char *cp)
static zic_t	gethms (const char *string, const char *errstring)
static zic_t	getsave (char *field, bool *isdst)
static void	inexpires (char **fields, int nfields)
static void	infile (const char *name)
static void	inleap (char **fields, int nfields)
static void	inlink (char **fields, int nfields)
static void	inrule (char **fields, int nfields)
static bool	inzcont (char **fields, int nfields)
static bool	inzone (char **fields, int nfields)
static bool	inzsub (char **fields, int nfields, bool iscont)
static bool	itsdir (char const *name)
static bool	itssymlink (char const *name)
static bool	is_alpha (char a)
static char	lowerit (char a)
static void	mkdirs (char const *argname, bool ancestors)
static void	newabbr (const char *string)
static zic_t	oadd (zic_t t1, zic_t t2)
static void	outzone (const struct zone *zpfirst, ptrdiff_t zonecount)
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 struct lookup const *	byword (const char *word, const struct lookup *table)
static _Noreturn void	memory_exhausted (const char *msg)
static size_t	size_product (size_t nitems, size_t itemsize)
static size_t	align_to (size_t size, size_t alignment)
static void *	memcheck (void *ptr)
static void *	emalloc (size_t size)
static void *	erealloc (void *ptr, size_t size)
static char *	ecpyalloc (char const *str)
static void *	growalloc (void *ptr, size_t itemsize, ptrdiff_t nitems, ptrdiff_t *nitems_alloc)
static void	eats (char const *name, lineno_t num, char const *rname, lineno_t rnum)
static void	eat (char const *name, lineno_t num)
static void	close_file (FILE *stream, char const *dir, char const *name)
static _Noreturn void	usage (FILE *stream, int status)
static void	change_directory (char const *dir)
static bool	timerange_option (char *timerange)
static bool	want_bloat (void)
int	main (int argc, char **argv)
static bool	componentcheck (char const *name, char const *component, char const *component_end)
static bool	namecheck (const char *name)
static char *	relname (char const *target, char const *linkname)
static int	hardlinkerr (char const *target, char const *linkname)
static int	rcomp (const void *cp1, const void *cp2)
static zic_t	getleapdatetime (char **fields, int nfields, bool expire_line)
static void	convert (const int_fast32_t val, char *const buf)
static void	convert64 (const zic_t val, char *const buf)
static void	puttzcode (const int_fast32_t val, FILE *const fp)
static void	puttzcodepass (zic_t val, FILE *fp, int pass)
static int	atcomp (const void *avp, const void *bvp)
static struct timerange	limitrange (struct timerange r, zic_t lo, zic_t hi, zic_t const *ats, unsigned char const *types)
static void	writezone (const char *const name, const char *const string, char version, int defaulttype)
static char const *	abbroffset (char *buf, zic_t offset)
static size_t	doabbr (char *abbr, struct zone const *zp, char const *letters, bool isdst, zic_t save, bool doquotes)
static void	updateminmax (const zic_t x)
static int	stringoffset (char *result, zic_t offset)
static int	stringrule (char *result, struct rule *const rp, zic_t save, zic_t stdoff)
static int	rule_cmp (struct rule const *a, struct rule const *b)
static int	stringzone (char *result, struct zone const *zpfirst, ptrdiff_t zonecount)
static bool	is_space (char a)
static bool	ciequal (const char *ap, const char *bp)
static bool	itsabbr (const char *abbr, const char *word)
static bool	ciprefix (char const *abbr, char const *word)
static _Noreturn void	time_overflow (void)

Variables
static ptrdiff_t const	PTRDIFF_MAX = MAXVAL(ptrdiff_t, TYPE_BIT(ptrdiff_t))
static int	charcnt
static bool	errors
static bool	warnings
static const char *	filename
static int	leapcnt
static bool	leapseen
static zic_t	leapminyear
static zic_t	leapmaxyear
static lineno_t	linenum
static int	max_abbrvar_len = PERCENT_Z_LEN_BOUND
static int	max_format_len
static zic_t	max_year
static zic_t	min_year
static bool	noise
static bool	print_abbrevs
static zic_t	print_cutoff
static const char *	rfilename
static lineno_t	rlinenum
static const char *	progname
static ptrdiff_t	timecnt
static ptrdiff_t	timecnt_alloc
static int	typecnt
static struct rule *	rules
static ptrdiff_t	nrules
static ptrdiff_t	nrules_alloc
static struct zone *	zones
static ptrdiff_t	nzones
static ptrdiff_t	nzones_alloc
static struct link *	links
static ptrdiff_t	nlinks
static ptrdiff_t	nlinks_alloc
static struct lookup const	zi_line_codes []
static struct lookup const	leap_line_codes []
static struct lookup const	mon_names []
static struct lookup const	wday_names []
static struct lookup const	lasts []
static struct lookup const	begin_years []
static struct lookup const	end_years []
static struct lookup const	leap_types []
static const int	len_months [2][MONSPERYEAR]
static const int	len_years [2]
static struct attype *	attypes
static zic_t	utoffs [TZ_MAX_TYPES]
static char	isdsts [TZ_MAX_TYPES]
static unsigned char	desigidx [TZ_MAX_TYPES]
static bool	ttisstds [TZ_MAX_TYPES]
static bool	ttisuts [TZ_MAX_TYPES]
static char	chars [TZ_MAX_CHARS]
static zic_t	trans [TZ_MAX_LEAPS]
static zic_t	corr [TZ_MAX_LEAPS]
static char	roll [TZ_MAX_LEAPS]
static zic_t const	min_time = MINVAL(zic_t, TIME_T_BITS_IN_FILE)
static zic_t const	max_time = MAXVAL(zic_t, TIME_T_BITS_IN_FILE)
static zic_t	lo_time = MINVAL(zic_t, TIME_T_BITS_IN_FILE)
static zic_t	hi_time = MAXVAL(zic_t, TIME_T_BITS_IN_FILE)
static zic_t	leapexpires = -1
static zic_t	comment_leapexpires = -1
static const char *	psxrules
static const char *	lcltime
static const char *	directory
static const char *	leapsec
static const char *	tzdefault
static int	bloat

Macro Definition Documentation

_Alignof

#define _Alignof

(

type

)

offsetof(struct { char a; type b; }, b)

Definition at line 54 of file zic.c.

DC_DOM

#define DC_DOM   0 /* 1..31 */ /* unused */

Definition at line 96 of file zic.c.

DC_DOWGEQ

#define DC_DOWGEQ   1 /* 1..31 */ /* 0..6 (Sun..Sat) */

Definition at line 97 of file zic.c.

DC_DOWLEQ

#define DC_DOWLEQ   2 /* 1..31 */ /* 0..6 (Sun..Sat) */

Definition at line 98 of file zic.c.

DO

#define DO

(

field

)

fwrite(tzh.field, sizeof tzh.field, 1, fp)

EXPIRES_FIELDS

#define EXPIRES_FIELDS   5

Definition at line 280 of file zic.c.

LC_EXPIRES

#define LC_EXPIRES   4

Definition at line 213 of file zic.c.

LC_LEAP

#define LC_LEAP   3

Definition at line 212 of file zic.c.

LC_LINK

#define LC_LINK   2

Definition at line 211 of file zic.c.

LC_RULE

#define LC_RULE   0

Definition at line 209 of file zic.c.

LC_ZONE

#define LC_ZONE   1

Definition at line 210 of file zic.c.

LDAYSPERWEEK

#define LDAYSPERWEEK   ((zic_t) DAYSPERWEEK)

LEAP_FIELDS

#define LEAP_FIELDS   7

Definition at line 277 of file zic.c.

LF_LINKNAME

#define LF_LINKNAME   2

Definition at line 264 of file zic.c.

LF_TARGET

#define LF_TARGET   1

Definition at line 263 of file zic.c.

LINK_FIELDS

#define LINK_FIELDS   3

Definition at line 265 of file zic.c.

linkat

#define linkat	(		targetdir,
			target,
			linknamedir,
			linkname,
			flag
	)		(itssymlink(target) ? (errno = ENOTSUP, -1) : link(target, linkname))

Definition at line 123 of file zic.c.

                                                : link(target, linkname))

LP_CORR

#define LP_CORR   5

Definition at line 275 of file zic.c.

LP_DAY

#define LP_DAY   3

Definition at line 273 of file zic.c.

LP_MONTH

#define LP_MONTH   2

Definition at line 272 of file zic.c.

LP_ROLL

#define LP_ROLL   6

Definition at line 276 of file zic.c.

LP_TIME

#define LP_TIME   4

Definition at line 274 of file zic.c.

LP_YEAR

#define LP_YEAR   1

Definition at line 271 of file zic.c.

MKDIR_UMASK

#define MKDIR_UMASK   0755

Definition at line 39 of file zic.c.

PRIdZIC

#define PRIdZIC   PRIdFAST64

Definition at line 28 of file zic.c.

RF_ABBRVAR

#define RF_ABBRVAR   9

Definition at line 256 of file zic.c.

RF_COMMAND

#define RF_COMMAND   4

Definition at line 251 of file zic.c.

RF_DAY

#define RF_DAY   6

Definition at line 253 of file zic.c.

RF_HIYEAR

#define RF_HIYEAR   3

Definition at line 250 of file zic.c.

RF_LOYEAR

#define RF_LOYEAR   2

Definition at line 249 of file zic.c.

RF_MONTH

#define RF_MONTH   5

Definition at line 252 of file zic.c.

RF_NAME

#define RF_NAME   1

Definition at line 248 of file zic.c.

RF_SAVE

#define RF_SAVE   8

Definition at line 255 of file zic.c.

RF_TOD

#define RF_TOD   7

Definition at line 254 of file zic.c.

RULE_FIELDS

#define RULE_FIELDS   10

Definition at line 257 of file zic.c.

SCNdZIC

#define SCNdZIC   SCNdFAST64

Definition at line 29 of file zic.c.

TIME_T_BITS_IN_FILE

#define TIME_T_BITS_IN_FILE   64

Definition at line 602 of file zic.c.

YR_MAXIMUM

#define YR_MAXIMUM   1

Definition at line 287 of file zic.c.

YR_MINIMUM

#define YR_MINIMUM   0

Definition at line 286 of file zic.c.

YR_ONLY

#define YR_ONLY   2

Definition at line 288 of file zic.c.

ZF_FORMAT

#define ZF_FORMAT   4

Definition at line 222 of file zic.c.

ZF_NAME

#define ZF_NAME   1

Definition at line 219 of file zic.c.

ZF_RULE

#define ZF_RULE   3

Definition at line 221 of file zic.c.

ZF_STDOFF

#define ZF_STDOFF   2

Definition at line 220 of file zic.c.

ZF_TILDAY

#define ZF_TILDAY   7

Definition at line 225 of file zic.c.

ZF_TILMONTH

#define ZF_TILMONTH   6

Definition at line 224 of file zic.c.

ZF_TILTIME

#define ZF_TILTIME   8

Definition at line 226 of file zic.c.

ZF_TILYEAR

#define ZF_TILYEAR   5

Definition at line 223 of file zic.c.

ZFC_FORMAT

#define ZFC_FORMAT   2

Definition at line 236 of file zic.c.

ZFC_RULE

#define ZFC_RULE   1

Definition at line 235 of file zic.c.

ZFC_STDOFF

#define ZFC_STDOFF   0

Definition at line 234 of file zic.c.

ZFC_TILDAY

#define ZFC_TILDAY   5

Definition at line 239 of file zic.c.

ZFC_TILMONTH

#define ZFC_TILMONTH   4

Definition at line 238 of file zic.c.

ZFC_TILTIME

#define ZFC_TILTIME   6

Definition at line 240 of file zic.c.

ZFC_TILYEAR

#define ZFC_TILYEAR   3

Definition at line 237 of file zic.c.

ZIC_BLOAT_DEFAULT

#define ZIC_BLOAT_DEFAULT   "slim"

Definition at line 676 of file zic.c.

ZIC_MAX

#define ZIC_MAX   INT_FAST64_MAX

Definition at line 27 of file zic.c.

ZIC_MAX_ABBR_LEN_WO_WARN

#define ZIC_MAX_ABBR_LEN_WO_WARN   6

Definition at line 32 of file zic.c.

ZIC_MIN

#define ZIC_MIN   INT_FAST64_MIN

Definition at line 26 of file zic.c.

ZIC_VERSION

#define ZIC_VERSION   '3'

Definition at line 23 of file zic.c.

ZIC_VERSION_PRE_2013

#define ZIC_VERSION_PRE_2013   '2'

Definition at line 22 of file zic.c.

ZONE_MAXFIELDS

#define ZONE_MAXFIELDS   9

Definition at line 228 of file zic.c.

ZONE_MINFIELDS

#define ZONE_MINFIELDS   5

Definition at line 227 of file zic.c.

ZONEC_MAXFIELDS

#define ZONEC_MAXFIELDS   7

Definition at line 242 of file zic.c.

ZONEC_MINFIELDS

#define ZONEC_MINFIELDS   3

Definition at line 241 of file zic.c.

Typedef Documentation

lineno_t

typedef intmax_t lineno_t

Definition at line 62 of file zic.c.

zic_t

typedef int_fast64_t zic_t

Definition at line 25 of file zic.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
PERCENT_Z_LEN_BOUND

Definition at line 165 of file zic.c.

{
PERCENT_Z_LEN_BOUND = sizeof "+995959" - 1};

anonymous enum

anonymous enum

Enumerator
WORK_AROUND_QTBUG_53071

Definition at line 177 of file zic.c.

{
WORK_AROUND_QTBUG_53071 = true};

Function Documentation

abbroffset()

static char const * abbroffset ( char *  buf, zic_t  offset  )

static

Definition at line 2589 of file zic.c.

{
    char        sign = '+';
    int         seconds,
                minutes;
 
    if (offset < 0)
    {
        offset = -offset;
        sign = '-';
    }
 
    seconds = offset % SECSPERMIN;
    offset /= SECSPERMIN;
    minutes = offset % MINSPERHOUR;
    offset /= MINSPERHOUR;
    if (100 <= offset)
    {
        error(_("%%z UT offset magnitude exceeds 99:59:59"));
        return "%z";
    }
    else
    {
        char       *p = buf;
 
        *p++ = sign;
        *p++ = '0' + offset / 10;
        *p++ = '0' + offset % 10;
        if (minutes | seconds)
        {
            *p++ = '0' + minutes / 10;
            *p++ = '0' + minutes % 10;
            if (seconds)
            {
                *p++ = '0' + seconds / 10;
                *p++ = '0' + seconds % 10;
            }
        }
        *p = '\0';
        return buf;
    }
}

References _, buf, error(), fb(), MINSPERHOUR, SECSPERMIN, and sign.

Referenced by doabbr().

addtt()

static void addtt ( zic_t  starttime, int  type  )

static

Definition at line 3351 of file zic.c.

{
    attypes = growalloc(attypes, sizeof *attypes, timecnt, &timecnt_alloc);
    attypes[timecnt].at = starttime;
    attypes[timecnt].dontmerge = false;
    attypes[timecnt].type = type;
    ++timecnt;
}

References attype::at, attypes, attype::dontmerge, growalloc(), timecnt, timecnt_alloc, type, and attype::type.

Referenced by outzone().

addtype()

static int addtype ( zic_t  utoff, char const *  abbr, bool  isdst, bool  ttisstd, bool  ttisut  )

static

Definition at line 3361 of file zic.c.

{
    int         i,
                j;
 
    if (!(-1L - 2147483647L <= utoff && utoff <= 2147483647L))
    {
        error(_("UT offset out of range"));
        exit(EXIT_FAILURE);
    }
    if (!want_bloat())
        ttisstd = ttisut = false;
 
    for (j = 0; j < charcnt; ++j)
        if (strcmp(&chars[j], abbr) == 0)
            break;
    if (j == charcnt)
        newabbr(abbr);
    else
    {
        /* If there's already an entry, return its index.  */
        for (i = 0; i < typecnt; i++)
            if (utoff == utoffs[i] && isdst == isdsts[i] && j == desigidx[i]
                && ttisstd == ttisstds[i] && ttisut == ttisuts[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);
    }
    i = typecnt++;
    utoffs[i] = utoff;
    isdsts[i] = isdst;
    ttisstds[i] = ttisstd;
    ttisuts[i] = ttisut;
    desigidx[i] = j;
    return i;
}

References _, charcnt, chars, desigidx, error(), EXIT_FAILURE, fb(), i, isdsts, j, newabbr(), ttisstds, ttisuts, typecnt, TZ_MAX_TYPES, utoffs, and want_bloat().

Referenced by outzone(), and writezone().

adjleap()

static void adjleap ( void  )

static

Definition at line 3428 of file zic.c.

{
    int         i;
    zic_t       last = 0;
    zic_t       prevtrans = 0;
 
    /*
     * propagate leap seconds forward
     */
    for (i = 0; i < leapcnt; ++i)
    {
        if (trans[i] - prevtrans < 28 * SECSPERDAY)
        {
            error(_("Leap seconds too close together"));
            exit(EXIT_FAILURE);
        }
        prevtrans = trans[i];
        trans[i] = tadd(trans[i], last);
        last = corr[i] += last;
    }
 
    if (leapexpires < 0)
    {
        leapexpires = comment_leapexpires;
        if (0 <= leapexpires)
            warning(_("\"#expires\" is obsolescent; use \"Expires\""));
    }
 
    if (0 <= leapexpires)
    {
        leapexpires = oadd(leapexpires, last);
        if (!(leapcnt == 0 || (trans[leapcnt - 1] < leapexpires)))
        {
            error(_("last Leap time does not precede Expires time"));
            exit(EXIT_FAILURE);
        }
        if (leapexpires <= hi_time)
            hi_time = leapexpires - 1;
    }
}

References _, comment_leapexpires, corr, error(), EXIT_FAILURE, fb(), hi_time, i, leapcnt, leapexpires, oadd(), SECSPERDAY, tadd(), trans, and warning().

Referenced by main().

align_to()

static size_t align_to ( size_t  size, size_t  alignment  )

static

Definition at line 433 of file zic.c.

{
    size_t      aligned_size = size + alignment - 1;
 
    aligned_size -= aligned_size % alignment;
    if (aligned_size < size)
        memory_exhausted(_("alignment overflow"));
    return aligned_size;
}

References _, fb(), and memory_exhausted().

Referenced by writezone().

associate()

static void associate ( void  )

static

Definition at line 1186 of file zic.c.

{
    struct zone *zp;
    struct rule *rp;
    ptrdiff_t   i,
                j,
                base,
                out;
 
    if (nrules != 0)
    {
        qsort(rules, nrules, sizeof *rules, rcomp);
        for (i = 0; i < nrules - 1; ++i)
        {
            if (strcmp(rules[i].r_name,
                       rules[i + 1].r_name) != 0)
                continue;
            if (strcmp(rules[i].r_filename,
                       rules[i + 1].r_filename) == 0)
                continue;
            eat(rules[i].r_filename, rules[i].r_linenum);
            warning(_("same rule name in multiple files"));
            eat(rules[i + 1].r_filename, rules[i + 1].r_linenum);
            warning(_("same rule name in multiple files"));
            for (j = i + 2; j < nrules; ++j)
            {
                if (strcmp(rules[i].r_name,
                           rules[j].r_name) != 0)
                    break;
                if (strcmp(rules[i].r_filename,
                           rules[j].r_filename) == 0)
                    continue;
                if (strcmp(rules[i + 1].r_filename,
                           rules[j].r_filename) == 0)
                    continue;
                break;
            }
            i = j - 1;
        }
    }
    for (i = 0; i < nzones; ++i)
    {
        zp = &zones[i];
        zp->z_rules = NULL;
        zp->z_nrules = 0;
    }
    for (base = 0; base < nrules; base = out)
    {
        rp = &rules[base];
        for (out = base + 1; out < nrules; ++out)
            if (strcmp(rp->r_name, rules[out].r_name) != 0)
                break;
        for (i = 0; i < nzones; ++i)
        {
            zp = &zones[i];
            if (strcmp(zp->z_rule, rp->r_name) != 0)
                continue;
            zp->z_rules = rp;
            zp->z_nrules = out - base;
        }
    }
    for (i = 0; i < nzones; ++i)
    {
        zp = &zones[i];
        if (zp->z_nrules == 0)
        {
            /*
             * Maybe we have a local standard time offset.
             */
            eat(zp->z_filename, zp->z_linenum);
            zp->z_save = getsave(zp->z_rule, &zp->z_isdst);
 
            /*
             * Note, though, that if there's no rule, a '%s' in the format is
             * a bad thing.
             */
            if (zp->z_format_specifier == 's')
                error("%s", _("%s in ruleless zone"));
        }
    }
    if (errors)
        exit(EXIT_FAILURE);
}

References _, eat(), error(), errors, EXIT_FAILURE, fb(), getsave(), i, j, nrules, nzones, qsort, rule::r_filename, rule::r_linenum, rule::r_name, rcomp(), rules, warning(), zone::z_rules, and zones.

Referenced by main().

atcomp()

static int atcomp ( const void *  avp, const void *  bvp  )

static

Definition at line 2039 of file zic.c.

{
    const zic_t a = ((const struct attype *) avp)->at;
    const zic_t b = ((const struct attype *) bvp)->at;
 
    return (a < b) ? -1 : (a > b);
}

References a, b, and fb().

Referenced by writezone().

byword()

static const struct lookup * byword ( const char *  word, const struct lookup *  table  )

static

Definition at line 3656 of file zic.c.

{
    const struct lookup *foundlp;
    const struct lookup *lp;
 
    if (word == NULL || table == NULL)
        return NULL;
 
    /*
     * If TABLE is LASTS and the word starts with "last" followed by a
     * non-'-', skip the "last" and look in WDAY_NAMES instead. Warn about any
     * usage of the undocumented prefix "last-".
     */
    if (table == lasts && ciprefix("last", word) && word[4])
    {
        if (word[4] == '-')
            warning(_("\"%s\" is undocumented; use \"last%s\" instead"),
                    word, word + 5);
        else
        {
            word += 4;
            table = wday_names;
        }
    }
 
    /*
     * Look for exact match.
     */
    for (lp = table; lp->l_word != NULL; ++lp)
        if (ciequal(word, lp->l_word))
            return lp;
 
    /*
     * Look for inexact match.
     */
    foundlp = NULL;
    for (lp = table; lp->l_word != NULL; ++lp)
        if (ciprefix(word, lp->l_word))
        {
            if (foundlp == NULL)
                foundlp = lp;
            else
                return NULL;    /* multiple inexact matches */
        }
 
    if (foundlp && noise)
    {
        /* Warn about any backward-compatibility issue with pre-2017c zic.  */
        bool        pre_2017c_match = false;
 
        for (lp = table; lp->l_word; lp++)
            if (itsabbr(word, lp->l_word))
            {
                if (pre_2017c_match)
                {
                    warning(_("\"%s\" is ambiguous in pre-2017c zic"), word);
                    break;
                }
                pre_2017c_match = true;
            }
    }
 
    return foundlp;
}

References _, ciequal(), ciprefix(), fb(), itsabbr(), lasts, noise, table, warning(), wday_names, and word().

Referenced by getleapdatetime(), infile(), inleap(), and rulesub().

change_directory()

static void change_directory ( char const *  dir )

static

Definition at line 582 of file zic.c.

{
    if (chdir(dir) != 0)
    {
        int         chdir_errno = errno;
 
        if (chdir_errno == ENOENT)
        {
            mkdirs(dir, false);
            chdir_errno = chdir(dir) == 0 ? 0 : errno;
        }
        if (chdir_errno != 0)
        {
            fprintf(stderr, _("%s: Can't chdir to %s: %s\n"),
                    progname, dir, strerror(chdir_errno));
            exit(EXIT_FAILURE);
        }
    }
}

References _, EXIT_FAILURE, fb(), fprintf, mkdirs(), progname, and strerror.

Referenced by main().

ciequal()

static bool ciequal ( const char *  ap, const char *  bp  )

static

Definition at line 3619 of file zic.c.

{
    while (lowerit(*ap) == lowerit(*bp++))
        if (*ap++ == '\0')
            return true;
    return false;
}

References fb(), and lowerit().

Referenced by byword().

ciprefix()

static bool ciprefix ( char const *  abbr, char const *  word  )

static

Definition at line 3645 of file zic.c.

{
    do
        if (!*abbr)
            return true;
    while (lowerit(*abbr++) == lowerit(*word++));
 
    return false;
}

References fb(), lowerit(), and word().

Referenced by byword().

close_file()

static void close_file ( FILE *  stream, char const *  dir, char const *  name  )

static

Definition at line 545 of file zic.c.

{
    char const *e = (ferror(stream) ? _("I/O error")
                     : fclose(stream) != 0 ? strerror(errno) : NULL);
 
    if (e)
    {
        fprintf(stderr, "%s: %s%s%s%s%s\n", progname,
                dir ? dir : "", dir ? "/" : "",
                name ? name : "", name ? ": " : "",
                e);
        exit(EXIT_FAILURE);
    }
}

References _, EXIT_FAILURE, fb(), fprintf, name, progname, and strerror.

Referenced by dolink(), infile(), main(), usage(), and writezone().

componentcheck()

static bool componentcheck ( char const *  name, char const *  component, char const *  component_end  )

static

Definition at line 885 of file zic.c.

{
    enum
    {
    component_len_max = 14};
    ptrdiff_t   component_len = component_end - component;
 
    if (component_len == 0)
    {
        if (!*name)
            error(_("empty file name"));
        else
            error(_(component == name
                    ? "file name '%s' begins with '/'"
                    : *component_end
                    ? "file name '%s' contains '//'"
                    : "file name '%s' ends with '/'"),
                  name);
        return false;
    }
    if (0 < component_len && component_len <= 2
        && component[0] == '.' && component_end[-1] == '.')
    {
        int         len = component_len;
 
        error(_("file name '%s' contains '%.*s' component"),
              name, len, component);
        return false;
    }
    if (noise)
    {
        if (0 < component_len && component[0] == '-')
            warning(_("file name '%s' component contains leading '-'"),
                    name);
        if (component_len_max < component_len)
            warning(_("file name '%s' contains overlength component"
                      " '%.*s...'"),
                    name, component_len_max, component);
    }
    return true;
}

References _, error(), fb(), len, name, noise, and warning().

Referenced by namecheck().

convert()

static void convert ( const int_fast32_t  val, char *const  buf  )

static

Definition at line 1994 of file zic.c.

{
    int         i;
    int         shift;
    unsigned char *const b = (unsigned char *) buf;
 
    for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
        b[i] = val >> shift;
}

References b, buf, i, and val.

Referenced by ExecInitExprRec(), fmtfloat(), fmtint(), fmtptr(), get_rule_expr(), pg_strfromd(), print_double(), print_double(), print_double(), print_double(), puttzcode(), and writezone().

convert64()

static void convert64 ( const zic_t  val, char *const  buf  )

static

Definition at line 2005 of file zic.c.

{
    int         i;
    int         shift;
    unsigned char *const b = (unsigned char *) buf;
 
    for (i = 0, shift = 56; i < 8; ++i, shift -= 8)
        b[i] = val >> shift;
}

References b, buf, i, and val.

Referenced by puttzcodepass().

doabbr()

static size_t doabbr ( char *  abbr, struct zone const *  zp, char const *  letters, bool  isdst, zic_t  save, bool  doquotes  )

static

Definition at line 2633 of file zic.c.

{
    char       *cp;
    char const *slashp;
    size_t      len;
    char const *format = zp->z_format;
 
    slashp = strchr(format, '/');
    if (slashp == NULL)
    {
        char        letterbuf[PERCENT_Z_LEN_BOUND + 1];
 
        if (zp->z_format_specifier == 'z')
            letters = abbroffset(letterbuf, zp->z_stdoff + save);
        else if (!letters)
            letters = "%s";
        sprintf(abbr, format, letters);
    }
    else if (isdst)
    {
        strcpy(abbr, slashp + 1);
    }
    else
    {
        memcpy(abbr, format, slashp - format);
        abbr[slashp - format] = '\0';
    }
    len = strlen(abbr);
    if (!doquotes)
        return len;
    for (cp = abbr; is_alpha(*cp); cp++)
        continue;
    if (len > 0 && *cp == '\0')
        return len;
    abbr[len + 2] = '\0';
    abbr[len + 1] = '>';
    memmove(abbr + 1, abbr, len);
    abbr[0] = '<';
    return len + 2;
}

References abbroffset(), fb(), format, is_alpha(), len, memcpy(), PERCENT_Z_LEN_BOUND, and sprintf.

Referenced by outzone(), and stringzone().

dolink()

static void dolink ( const char *  target, const char *  linkname, bool  staysymlink  )

static

Definition at line 1032 of file zic.c.

{
    bool        remove_only = strcmp(target, "-") == 0;
    bool        linkdirs_made = false;
    int         link_errno;
 
    /*
     * We get to be careful here since there's a fair chance of root running
     * us.
     */
    if (!remove_only && itsdir(target))
    {
        fprintf(stderr, _("%s: linking target %s/%s failed: %s\n"),
                progname, directory, target, strerror(EPERM));
        exit(EXIT_FAILURE);
    }
    if (staysymlink)
        staysymlink = itssymlink(linkname);
    if (remove(linkname) == 0)
        linkdirs_made = true;
    else if (errno != ENOENT)
    {
        char const *e = strerror(errno);
 
        fprintf(stderr, _("%s: Can't remove %s/%s: %s\n"),
                progname, directory, linkname, e);
        exit(EXIT_FAILURE);
    }
    if (remove_only)
        return;
    link_errno = staysymlink ? ENOTSUP : hardlinkerr(target, linkname);
    if (link_errno == ENOENT && !linkdirs_made)
    {
        mkdirs(linkname, true);
        linkdirs_made = true;
        link_errno = hardlinkerr(target, linkname);
    }
    if (link_errno != 0)
    {
#ifdef HAVE_SYMLINK
        bool        absolute = *target == '/';
        char       *linkalloc = absolute ? NULL : relname(target, linkname);
        char const *contents = absolute ? target : linkalloc;
        int         symlink_errno = symlink(contents, linkname) == 0 ? 0 : errno;
 
        if (!linkdirs_made
            && (symlink_errno == ENOENT || symlink_errno == ENOTSUP))
        {
            mkdirs(linkname, true);
            if (symlink_errno == ENOENT)
                symlink_errno = symlink(contents, linkname) == 0 ? 0 : errno;
        }
        free(linkalloc);
        if (symlink_errno == 0)
        {
            if (link_errno != ENOTSUP)
                warning(_("symbolic link used because hard link failed: %s"),
                        strerror(link_errno));
        }
        else
#endif                          /* HAVE_SYMLINK */
        {
            FILE       *fp,
                       *tp;
            int         c;
 
            fp = fopen(target, "rb");
            if (!fp)
            {
                char const *e = strerror(errno);
 
                fprintf(stderr, _("%s: Can't read %s/%s: %s\n"),
                        progname, directory, target, e);
                exit(EXIT_FAILURE);
            }
            tp = fopen(linkname, "wb");
            if (!tp)
            {
                char const *e = strerror(errno);
 
                fprintf(stderr, _("%s: Can't create %s/%s: %s\n"),
                        progname, directory, linkname, e);
                exit(EXIT_FAILURE);
            }
            while ((c = getc(fp)) != EOF)
                putc(c, tp);
            close_file(fp, directory, target);
            close_file(tp, directory, linkname);
            if (link_errno != ENOTSUP)
                warning(_("copy used because hard link failed: %s"),
                        strerror(link_errno));
#ifdef HAVE_SYMLINK
            else if (symlink_errno != ENOTSUP)
                warning(_("copy used because symbolic link failed: %s"),
                        strerror(symlink_errno));
#endif
        }
    }
}

References _, close_file(), directory, ENOTSUP, EXIT_FAILURE, fb(), fprintf, free, hardlinkerr(), itsdir(), itssymlink(), mkdirs(), progname, relname, strerror, symlink, and warning().

Referenced by main().

eat()

static void eat ( char const *  name, lineno_t  num  )

static

Definition at line 500 of file zic.c.

{
    eats(name, num, NULL, -1);
}

References eats(), fb(), and name.

Referenced by associate(), infile(), main(), and outzone().

eats()

static void eats ( char const *  name, lineno_t  num, char const *  rname, lineno_t  rnum  )

static

Definition at line 491 of file zic.c.

{
    filename = name;
    linenum = num;
    rfilename = rname;
    rlinenum = rnum;
}

References fb(), filename, linenum, name, rfilename, and rlinenum.

Referenced by eat(), and outzone().

ecpyalloc()

static char * ecpyalloc ( char const *  str )

static

Definition at line 464 of file zic.c.

{
    return memcheck(strdup(str));
}

References fb(), memcheck(), and str.

Referenced by inlink(), inrule(), inzsub(), mkdirs(), and rulesub().

emalloc()

static void * emalloc ( size_t  size )

static

Definition at line 452 of file zic.c.

{
    return memcheck(malloc(size));
}

References malloc, and memcheck().

Referenced by getfields(), itsdir(), outzone(), relname(), and writezone().

erealloc()

static void * erealloc ( void *  ptr, size_t  size  )

static

Definition at line 458 of file zic.c.

{
    return memcheck(realloc(ptr, size));
}

References memcheck(), and realloc.

Referenced by growalloc().

error()

static void error ( const char *const  string,   ...  )

static

Definition at line 522 of file zic.c.

{
    va_list     args;
 
    va_start(args, string);
    verror(string, args);
    va_end(args);
    errors = true;
}

References errors, fb(), and verror().

getfields()

static char ** getfields ( char *  cp )

static

Definition at line 3722 of file zic.c.

{
    char       *dp;
    char      **array;
    int         nsubs;
 
    if (cp == NULL)
        return NULL;
    array = emalloc(size_product(strlen(cp) + 1, sizeof *array));
    nsubs = 0;
    for (;;)
    {
        while (is_space(*cp))
            ++cp;
        if (*cp == '\0' || *cp == '#')
            break;
        array[nsubs++] = dp = cp;
        do
        {
            if ((*dp = *cp++) != '"')
                ++dp;
            else
                while ((*dp = *cp++) != '"')
                    if (*dp != '\0')
                        ++dp;
                    else
                    {
                        error(_("Odd number of quotation marks"));
                        exit(EXIT_FAILURE);
                    }
        } while (*cp && *cp != '#' && !is_space(*cp));
        if (is_space(*cp))
            ++cp;
        *dp = '\0';
    }
    array[nsubs] = NULL;
    return array;
}

References _, emalloc(), error(), EXIT_FAILURE, fb(), is_space(), and size_product().

Referenced by infile().

gethms()

static zic_t gethms ( const char *  string, const char *  errstring  )

static

Definition at line 1380 of file zic.c.

{
    zic_t       hh;
    int         sign,
                mm = 0,
                ss = 0;
    char        hhx,
                mmx,
                ssx,
                xr = '0',
                xs;
    int         tenths = 0;
    bool        ok = true;
 
    if (string == NULL || *string == '\0')
        return 0;
    if (*string == '-')
    {
        sign = -1;
        ++string;
    }
    else
        sign = 1;
    switch (sscanf(string,
                   "%" SCNdZIC "%c%d%c%d%c%1d%*[0]%c%*[0123456789]%c",
                   &hh, &hhx, &mm, &mmx, &ss, &ssx, &tenths, &xr, &xs))
    {
        default:
            ok = false;
            break;
        case 8:
            ok = '0' <= xr && xr <= '9';
            pg_fallthrough;
        case 7:
            ok &= ssx == '.';
            if (ok && noise)
                warning(_("fractional seconds rejected by"
                          " pre-2018 versions of zic"));
            pg_fallthrough;
        case 5:
            ok &= mmx == ':';
            pg_fallthrough;
        case 3:
            ok &= hhx == ':';
            pg_fallthrough;
        case 1:
            break;
    }
    if (!ok)
    {
        error("%s", errstring);
        return 0;
    }
    if (hh < 0 ||
        mm < 0 || mm >= MINSPERHOUR ||
        ss < 0 || ss > SECSPERMIN)
    {
        error("%s", errstring);
        return 0;
    }
    if (ZIC_MAX / SECSPERHOUR < hh)
    {
        error(_("time overflow"));
        return 0;
    }
    ss += 5 + ((ss ^ 1) & (xr == '0')) <= tenths;   /* Round to even.  */
    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));
}

References _, error(), fb(), HOURSPERDAY, MINSPERHOUR, noise, oadd(), pg_fallthrough, SCNdZIC, SECSPERHOUR, SECSPERMIN, sign, warning(), and ZIC_MAX.

Referenced by getleapdatetime(), getsave(), inzsub(), and rulesub().

getleapdatetime()

static zic_t getleapdatetime ( char **  fields, int  nfields, bool  expire_line  )

static

Definition at line 1677 of file zic.c.

{
    const char *cp;
    const struct lookup *lp;
    zic_t       i,
                j;
    zic_t       year;
    int         month,
                day;
    zic_t       dayoff,
                tod;
    zic_t       t;
    char        xs;
 
    dayoff = 0;
    cp = fields[LP_YEAR];
    if (sscanf(cp, "%" SCNdZIC "%c", &year, &xs) != 1)
    {
        /*
         * Leapin' Lizards!
         */
        error(_("invalid leaping year"));
        return -1;
    }
    if (!expire_line)
    {
        if (!leapseen || leapmaxyear < year)
            leapmaxyear = year;
        if (!leapseen || leapminyear > year)
            leapminyear = year;
        leapseen = true;
    }
    j = EPOCH_YEAR;
    while (j != year)
    {
        if (year > j)
        {
            i = len_years[isleap(j)];
            ++j;
        }
        else
        {
            --j;
            i = -len_years[isleap(j)];
        }
        dayoff = oadd(dayoff, i);
    }
    if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL)
    {
        error(_("invalid month name"));
        return -1;
    }
    month = lp->l_value;
    j = TM_JANUARY;
    while (j != month)
    {
        i = len_months[isleap(year)][j];
        dayoff = oadd(dayoff, i);
        ++j;
    }
    cp = fields[LP_DAY];
    if (sscanf(cp, "%d%c", &day, &xs) != 1 ||
        day <= 0 || day > len_months[isleap(year)][month])
    {
        error(_("invalid day of month"));
        return -1;
    }
    dayoff = oadd(dayoff, day - 1);
    if (dayoff < min_time / SECSPERDAY)
    {
        error(_("time too small"));
        return -1;
    }
    if (dayoff > max_time / SECSPERDAY)
    {
        error(_("time too large"));
        return -1;
    }
    t = dayoff * SECSPERDAY;
    tod = gethms(fields[LP_TIME], _("invalid time of day"));
    t = tadd(t, tod);
    if (t < 0)
        error(_("leap second precedes Epoch"));
    return t;
}

References _, byword(), EPOCH_YEAR, error(), fb(), gethms(), i, isleap, j, leapmaxyear, leapminyear, leapseen, len_months, len_years, LP_DAY, LP_MONTH, LP_TIME, LP_YEAR, max_time, min_time, mon_names, oadd(), SCNdZIC, SECSPERDAY, tadd(), and TM_JANUARY.

Referenced by inexpires(), and inleap().

getsave()

static zic_t getsave ( char *  field, bool *  isdst  )

static

Definition at line 1454 of file zic.c.

{
    int         dst = -1;
    zic_t       save;
    size_t      fieldlen = strlen(field);
 
    if (fieldlen != 0)
    {
        char       *ep = field + fieldlen - 1;
 
        switch (*ep)
        {
            case 'd':
                dst = 1;
                *ep = '\0';
                break;
            case 's':
                dst = 0;
                *ep = '\0';
                break;
        }
    }
    save = gethms(field, _("invalid saved time"));
    *isdst = dst < 0 ? save != 0 : dst;
    return save;
}

References _, fb(), and gethms().

Referenced by associate(), and inrule().

growalloc()

static void * growalloc ( void *  ptr, size_t  itemsize, ptrdiff_t  nitems, ptrdiff_t *  nitems_alloc  )

static

Definition at line 470 of file zic.c.

{
    if (nitems < *nitems_alloc)
        return ptr;
    else
    {
        ptrdiff_t   nitems_max = PTRDIFF_MAX - WORK_AROUND_QTBUG_53071;
        ptrdiff_t   amax = nitems_max < SIZE_MAX ? nitems_max : SIZE_MAX;
 
        if ((amax - 1) / 3 * 2 < *nitems_alloc)
            memory_exhausted(_("integer overflow"));
        *nitems_alloc += (*nitems_alloc >> 1) + 1;
        return erealloc(ptr, size_product(*nitems_alloc, itemsize));
    }
}

References _, erealloc(), fb(), memory_exhausted(), nitems, PTRDIFF_MAX, size_product(), and WORK_AROUND_QTBUG_53071.

Referenced by addtt(), inlink(), inrule(), and inzsub().

hardlinkerr()

static int hardlinkerr ( char const *  target, char const *  linkname  )

static

Definition at line 1024 of file zic.c.

{
    int         r = linkat(AT_FDCWD, target, AT_FDCWD, linkname, AT_SYMLINK_FOLLOW);
 
    return r == 0 ? 0 : errno;
}

References fb(), and linkat.

Referenced by dolink().

inexpires()

static void inexpires ( char **  fields, int  nfields  )

static

Definition at line 1796 of file zic.c.

{
    if (nfields != EXPIRES_FIELDS)
        error(_("wrong number of fields on Expires line"));
    else if (0 <= leapexpires)
        error(_("multiple Expires lines"));
    else
        leapexpires = getleapdatetime(fields, nfields, true);
}

References _, error(), EXPIRES_FIELDS, getleapdatetime(), and leapexpires.

Referenced by infile().

infile()

static void infile ( const char *  name )

static

Definition at line 1271 of file zic.c.

{
    FILE       *fp;
    char      **fields;
    char       *cp;
    const struct lookup *lp;
    int         nfields;
    bool        wantcont;
    lineno_t    num;
    char        buf[BUFSIZ];
 
    if (strcmp(name, "-") == 0)
    {
        name = _("standard input");
        fp = stdin;
    }
    else if ((fp = fopen(name, "r")) == NULL)
    {
        const char *e = strerror(errno);
 
        fprintf(stderr, _("%s: Cannot open %s: %s\n"),
                progname, name, e);
        exit(EXIT_FAILURE);
    }
    wantcont = false;
    for (num = 1;; ++num)
    {
        eat(name, num);
        if (fgets(buf, sizeof buf, fp) != buf)
            break;
        cp = strchr(buf, '\n');
        if (cp == NULL)
        {
            error(_("line too long"));
            exit(EXIT_FAILURE);
        }
        *cp = '\0';
        fields = getfields(buf);
        nfields = 0;
        while (fields[nfields] != NULL)
        {
            static char nada;
 
            if (strcmp(fields[nfields], "-") == 0)
                fields[nfields] = &nada;
            ++nfields;
        }
        if (nfields == 0)
        {
            if (name == leapsec && *buf == '#')
                sscanf(buf, "#expires %" SCNdZIC, &comment_leapexpires);
        }
        else if (wantcont)
        {
            wantcont = inzcont(fields, nfields);
        }
        else
        {
            struct lookup const *line_codes
            = name == leapsec ? leap_line_codes : zi_line_codes;
 
            lp = byword(fields[0], line_codes);
            if (lp == NULL)
                error(_("input line of unknown type"));
            else
                switch (lp->l_value)
                {
                    case LC_RULE:
                        inrule(fields, nfields);
                        wantcont = false;
                        break;
                    case LC_ZONE:
                        wantcont = inzone(fields, nfields);
                        break;
                    case LC_LINK:
                        inlink(fields, nfields);
                        wantcont = false;
                        break;
                    case LC_LEAP:
                        inleap(fields, nfields);
                        wantcont = false;
                        break;
                    case LC_EXPIRES:
                        inexpires(fields, nfields);
                        wantcont = false;
                        break;
                    default:    /* "cannot happen" */
                        fprintf(stderr,
                                _("%s: panic: Invalid l_value %d\n"),
                                progname, lp->l_value);
                        exit(EXIT_FAILURE);
                }
        }
        free(fields);
    }
    close_file(fp, NULL, filename);
    if (wantcont)
        error(_("expected continuation line not found"));
}

References _, buf, byword(), close_file(), comment_leapexpires, eat(), error(), EXIT_FAILURE, fb(), filename, fprintf, free, getfields(), inexpires(), inleap(), inlink(), inrule(), inzcont(), inzone(), LC_EXPIRES, LC_LEAP, LC_LINK, LC_RULE, LC_ZONE, leap_line_codes, leapsec, name, progname, SCNdZIC, strerror, and zi_line_codes.

Referenced by AlterSystemSetConfigFile(), isolation_start_test(), main(), psql_start_test(), and readfile().

inleap()

static void inleap ( char **  fields, int  nfields  )

static

Definition at line 1764 of file zic.c.

{
    if (nfields != LEAP_FIELDS)
        error(_("wrong number of fields on Leap line"));
    else
    {
        zic_t       t = getleapdatetime(fields, nfields, false);
 
        if (0 <= t)
        {
            struct lookup const *lp = byword(fields[LP_ROLL], leap_types);
 
            if (!lp)
                error(_("invalid Rolling/Stationary field on Leap line"));
            else
            {
                int         correction = 0;
 
                if (!fields[LP_CORR][0])    /* infile() turns "-" into "".  */
                    correction = -1;
                else if (strcmp(fields[LP_CORR], "+") == 0)
                    correction = 1;
                else
                    error(_("invalid CORRECTION field on Leap line"));
                if (correction)
                    leapadd(t, correction, lp->l_value);
            }
        }
    }
}

References _, byword(), error(), fb(), getleapdatetime(), LEAP_FIELDS, leap_types, leapadd(), LP_CORR, and LP_ROLL.

Referenced by infile().

inlink()

static void inlink ( char **  fields, int  nfields  )

static

Definition at line 1807 of file zic.c.

{
    struct link l;
 
    if (nfields != LINK_FIELDS)
    {
        error(_("wrong number of fields on Link line"));
        return;
    }
    if (*fields[LF_TARGET] == '\0')
    {
        error(_("blank TARGET field on Link line"));
        return;
    }
    if (!namecheck(fields[LF_LINKNAME]))
        return;
    l.l_filename = filename;
    l.l_linenum = linenum;
    l.l_target = ecpyalloc(fields[LF_TARGET]);
    l.l_linkname = ecpyalloc(fields[LF_LINKNAME]);
    links = growalloc(links, sizeof *links, nlinks, &nlinks_alloc);
    links[nlinks++] = l;
}

References _, ecpyalloc(), error(), filename, growalloc(), link::l_filename, link::l_linenum, link::l_linkname, link::l_target, LF_LINKNAME, LF_TARGET, linenum, LINK_FIELDS, links, namecheck(), nlinks, and nlinks_alloc.

Referenced by infile().

inrule()

static void inrule ( char **  fields, int  nfields  )

static

Definition at line 1482 of file zic.c.

{
    static struct rule r;
 
    if (nfields != RULE_FIELDS)
    {
        error(_("wrong number of fields on Rule line"));
        return;
    }
    switch (*fields[RF_NAME])
    {
        case '\0':
        case ' ':
        case '\f':
        case '\n':
        case '\r':
        case '\t':
        case '\v':
        case '+':
        case '-':
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            error(_("Invalid rule name \"%s\""), fields[RF_NAME]);
            return;
    }
    r.r_filename = filename;
    r.r_linenum = linenum;
    r.r_save = getsave(fields[RF_SAVE], &r.r_isdst);
    rulesub(&r, fields[RF_LOYEAR], fields[RF_HIYEAR], fields[RF_COMMAND],
            fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
    r.r_name = ecpyalloc(fields[RF_NAME]);
    r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
    if (max_abbrvar_len < strlen(r.r_abbrvar))
        max_abbrvar_len = strlen(r.r_abbrvar);
    rules = growalloc(rules, sizeof *rules, nrules, &nrules_alloc);
    rules[nrules++] = r;
}

References _, ecpyalloc(), error(), fb(), filename, getsave(), growalloc(), linenum, max_abbrvar_len, nrules, nrules_alloc, rule::r_abbrvar, rule::r_filename, rule::r_isdst, rule::r_linenum, rule::r_name, rule::r_save, RF_ABBRVAR, RF_COMMAND, RF_DAY, RF_HIYEAR, RF_LOYEAR, RF_MONTH, RF_NAME, RF_SAVE, RF_TOD, RULE_FIELDS, rules, and rulesub().

Referenced by infile().

inzcont()

static bool inzcont ( char **  fields, int  nfields  )

static

Definition at line 1567 of file zic.c.

{
    if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS)
    {
        error(_("wrong number of fields on Zone continuation line"));
        return false;
    }
    return inzsub(fields, nfields, true);
}

References _, error(), fb(), inzsub(), and ZONEC_MAXFIELDS.

Referenced by infile().

inzone()

static bool inzone ( char **  fields, int  nfields  )

static

Definition at line 1529 of file zic.c.

{
    ptrdiff_t   i;
 
    if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS)
    {
        error(_("wrong number of fields on Zone line"));
        return false;
    }
    if (lcltime != NULL && strcmp(fields[ZF_NAME], tzdefault) == 0)
    {
        error(
              _("\"Zone %s\" line and -l option are mutually exclusive"),
              tzdefault);
        return false;
    }
    if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL)
    {
        error(
              _("\"Zone %s\" line and -p option are mutually exclusive"),
              TZDEFRULES);
        return false;
    }
    for (i = 0; i < nzones; ++i)
        if (zones[i].z_name != NULL &&
            strcmp(zones[i].z_name, fields[ZF_NAME]) == 0)
        {
            error(_("duplicate zone name %s"
                    " (file \"%s\", line %" PRIdMAX ")"),
                  fields[ZF_NAME],
                  zones[i].z_filename,
                  zones[i].z_linenum);
            return false;
        }
    return inzsub(fields, nfields, false);
}

References _, error(), fb(), i, inzsub(), lcltime, nzones, psxrules, tzdefault, TZDEFRULES, ZF_NAME, ZONE_MAXFIELDS, and zones.

Referenced by infile().

inzsub()

static bool inzsub ( char **  fields, int  nfields, bool  iscont  )

static

Definition at line 1578 of file zic.c.

{
    char       *cp;
    char       *cp1;
    static struct zone z;
    int         i_stdoff,
                i_rule,
                i_format;
    int         i_untilyear,
                i_untilmonth;
    int         i_untilday,
                i_untiltime;
    bool        hasuntil;
 
    if (iscont)
    {
        i_stdoff = ZFC_STDOFF;
        i_rule = ZFC_RULE;
        i_format = ZFC_FORMAT;
        i_untilyear = ZFC_TILYEAR;
        i_untilmonth = ZFC_TILMONTH;
        i_untilday = ZFC_TILDAY;
        i_untiltime = ZFC_TILTIME;
        z.z_name = NULL;
    }
    else if (!namecheck(fields[ZF_NAME]))
        return false;
    else
    {
        i_stdoff = ZF_STDOFF;
        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_stdoff = gethms(fields[i_stdoff], _("invalid UT offset"));
    if ((cp = strchr(fields[i_format], '%')) != NULL)
    {
        if ((*++cp != 's' && *cp != 'z') || strchr(cp, '%')
            || strchr(fields[i_format], '/'))
        {
            error(_("invalid abbreviation format"));
            return false;
        }
    }
    z.z_rule = ecpyalloc(fields[i_rule]);
    z.z_format = cp1 = ecpyalloc(fields[i_format]);
    z.z_format_specifier = cp ? *cp : '\0';
    if (z.z_format_specifier == 'z')
    {
        if (noise)
            warning(_("format '%s' not handled by pre-2015 versions of zic"),
                    z.z_format);
        cp1[cp - fields[i_format]] = 's';
    }
    if (max_format_len < strlen(z.z_format))
        max_format_len = strlen(z.z_format);
    hasuntil = nfields > i_untilyear;
    if (hasuntil)
    {
        z.z_untilrule.r_filename = filename;
        z.z_untilrule.r_linenum = linenum;
        rulesub(&z.z_untilrule,
                fields[i_untilyear],
                "only",
                "",
                (nfields > i_untilmonth) ?
                fields[i_untilmonth] : "Jan",
                (nfields > i_untilday) ? fields[i_untilday] : "1",
                (nfields > i_untiltime) ? fields[i_untiltime] : "0");
        z.z_untiltime = rpytime(&z.z_untilrule,
                                z.z_untilrule.r_loyear);
        if (iscont && nzones > 0 &&
            z.z_untiltime > min_time &&
            z.z_untiltime < max_time &&
            zones[nzones - 1].z_untiltime > min_time &&
            zones[nzones - 1].z_untiltime < max_time &&
            zones[nzones - 1].z_untiltime >= z.z_untiltime)
        {
            error(_("Zone continuation line end time is not after end time of previous line"));
            return false;
        }
    }
    zones = growalloc(zones, sizeof *zones, nzones, &nzones_alloc);
    zones[nzones++] = z;
 
    /*
     * If there was an UNTIL field on this line, there's more information
     * about the zone on the next line.
     */
    return hasuntil;
}

References _, ecpyalloc(), error(), fb(), filename, gethms(), growalloc(), linenum, max_format_len, max_time, min_time, namecheck(), noise, nzones, nzones_alloc, rule::r_filename, rule::r_linenum, rule::r_loyear, rpytime(), rulesub(), warning(), zone::z_filename, zone::z_format, zone::z_format_specifier, zone::z_linenum, zone::z_name, zone::z_rule, zone::z_stdoff, zone::z_untilrule, zone::z_untiltime, ZF_FORMAT, ZF_NAME, ZF_RULE, ZF_STDOFF, ZF_TILDAY, ZF_TILMONTH, ZF_TILTIME, ZF_TILYEAR, ZFC_FORMAT, ZFC_RULE, ZFC_STDOFF, ZFC_TILDAY, ZFC_TILMONTH, ZFC_TILTIME, ZFC_TILYEAR, and zones.

Referenced by inzcont(), and inzone().

is_alpha()

static bool is_alpha ( char  a )

static

Definition at line 3489 of file zic.c.

{
    switch (a)
    {
        default:
            return false;
        case 'A':
        case 'B':
        case 'C':
        case 'D':
        case 'E':
        case 'F':
        case 'G':
        case 'H':
        case 'I':
        case 'J':
        case 'K':
        case 'L':
        case 'M':
        case 'N':
        case 'O':
        case 'P':
        case 'Q':
        case 'R':
        case 'S':
        case 'T':
        case 'U':
        case 'V':
        case 'W':
        case 'X':
        case 'Y':
        case 'Z':
        case 'a':
        case 'b':
        case 'c':
        case 'd':
        case 'e':
        case 'f':
        case 'g':
        case 'h':
        case 'i':
        case 'j':
        case 'k':
        case 'l':
        case 'm':
        case 'n':
        case 'o':
        case 'p':
        case 'q':
        case 'r':
        case 's':
        case 't':
        case 'u':
        case 'v':
        case 'w':
        case 'x':
        case 'y':
        case 'z':
            return true;
    }
}

References a.

Referenced by doabbr(), and newabbr().

is_space()

static bool is_space ( char  a )

static

Definition at line 3471 of file zic.c.

{
    switch (a)
    {
        default:
            return false;
        case ' ':
        case '\f':
        case '\n':
        case '\r':
        case '\t':
        case '\v':
            return true;
    }
}

References a.

Referenced by getfields().

itsabbr()

static bool itsabbr ( const char *  abbr, const char *  word  )

static

Definition at line 3628 of file zic.c.

{
    if (lowerit(*abbr) != lowerit(*word))
        return false;
    ++word;
    while (*++abbr != '\0')
        do
        {
            if (*word == '\0')
                return false;
        } while (lowerit(*word++) != lowerit(*abbr));
    return true;
}

References fb(), lowerit(), and word().

Referenced by byword().

itsdir()

static bool itsdir ( char const *  name )

static

Definition at line 1134 of file zic.c.

{
    struct stat st;
    int         res = stat(name, &st);
#ifdef S_ISDIR
    if (res == 0)
        return S_ISDIR(st.st_mode) != 0;
#endif
    if (res == 0 || errno == EOVERFLOW)
    {
        size_t      n = strlen(name);
        char       *nameslashdot = emalloc(n + 3);
        bool        dir;
 
        memcpy(nameslashdot, name, n);
        strcpy(&nameslashdot[n], &"/."[!(n && name[n - 1] != '/')]);
        dir = stat(nameslashdot, &st) == 0 || errno == EOVERFLOW;
        free(nameslashdot);
        return dir;
    }
    return false;
}

References emalloc(), EOVERFLOW, fb(), free, memcpy(), name, S_ISDIR, stat::st_mode, and stat.

Referenced by dolink(), and mkdirs().

itssymlink()

static bool itssymlink ( char const *  name )

static

Definition at line 1159 of file zic.c.

{
#ifdef HAVE_SYMLINK
    char        c;
 
    return 0 <= readlink(name, &c, 1);
#else
    return false;
#endif
}

References name, and readlink.

Referenced by dolink().

leapadd()

static void leapadd ( zic_t  t, int  correction, int  rolling  )

static

Definition at line 3406 of file zic.c.

{
    int         i;
 
    if (TZ_MAX_LEAPS <= leapcnt)
    {
        error(_("too many leap seconds"));
        exit(EXIT_FAILURE);
    }
    for (i = 0; i < leapcnt; ++i)
        if (t <= trans[i])
            break;
    memmove(&trans[i + 1], &trans[i], (leapcnt - i) * sizeof *trans);
    memmove(&corr[i + 1], &corr[i], (leapcnt - i) * sizeof *corr);
    memmove(&roll[i + 1], &roll[i], (leapcnt - i) * sizeof *roll);
    trans[i] = t;
    corr[i] = correction;
    roll[i] = rolling;
    ++leapcnt;
}

References _, corr, error(), EXIT_FAILURE, fb(), i, leapcnt, roll, trans, and TZ_MAX_LEAPS.

Referenced by inleap().

limitrange()

static struct timerange limitrange ( struct timerange  r, zic_t  lo, zic_t  hi, zic_t const *  ats, unsigned char const *  types  )

static

Definition at line 2057 of file zic.c.

{
    while (0 < r.count && ats[r.base] < lo)
    {
        r.defaulttype = types[r.base];
        r.count--;
        r.base++;
    }
    while (0 < r.leapcount && trans[r.leapbase] < lo)
    {
        r.leapcount--;
        r.leapbase++;
    }
 
    if (hi < ZIC_MAX)
    {
        while (0 < r.count && hi + 1 < ats[r.base + r.count - 1])
            r.count--;
        while (0 < r.leapcount && hi + 1 < trans[r.leapbase + r.leapcount - 1])
            r.leapcount--;
    }
 
    return r;
}

References timerange::defaulttype, trans, types, and ZIC_MAX.

Referenced by writezone().

link()

int link ( const char *  target, const char *  linkname  )

extern

Definition at line 18 of file win32link.c.

{
    /*
     * CreateHardLinkA returns zero for failure
     * https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createhardlinka
     */
    if (CreateHardLinkA(dst, src, NULL) == 0)
    {
        _dosmaperr(GetLastError());
        return -1;
    }
    else
        return 0;
}

References _dosmaperr(), and fb().

lowerit()

static char lowerit ( char  a )

static

Definition at line 3556 of file zic.c.

{
    switch (a)
    {
        default:
            return a;
        case 'A':
            return 'a';
        case 'B':
            return 'b';
        case 'C':
            return 'c';
        case 'D':
            return 'd';
        case 'E':
            return 'e';
        case 'F':
            return 'f';
        case 'G':
            return 'g';
        case 'H':
            return 'h';
        case 'I':
            return 'i';
        case 'J':
            return 'j';
        case 'K':
            return 'k';
        case 'L':
            return 'l';
        case 'M':
            return 'm';
        case 'N':
            return 'n';
        case 'O':
            return 'o';
        case 'P':
            return 'p';
        case 'Q':
            return 'q';
        case 'R':
            return 'r';
        case 'S':
            return 's';
        case 'T':
            return 't';
        case 'U':
            return 'u';
        case 'V':
            return 'v';
        case 'W':
            return 'w';
        case 'X':
            return 'x';
        case 'Y':
            return 'y';
        case 'Z':
            return 'z';
    }
}

References a.

Referenced by ciequal(), ciprefix(), itsabbr(), and rulesub().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 680 of file zic.c.

{
    int         c,
                k;
    ptrdiff_t   i,
                j;
    bool        timerange_given = false;
 
#ifndef WIN32
    umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
#endif
    progname = argv[0];
    if (TYPE_BIT(zic_t) < 64)
    {
        fprintf(stderr, "%s: %s\n", progname,
                _("wild compilation-time specification of zic_t"));
        return EXIT_FAILURE;
    }
    for (k = 1; k < argc; k++)
        if (strcmp(argv[k], "--version") == 0)
        {
            printf("zic %s\n", PG_VERSION);
            close_file(stdout, NULL, NULL);
            return EXIT_SUCCESS;
        }
        else if (strcmp(argv[k], "--help") == 0)
        {
            usage(stdout, EXIT_SUCCESS);
        }
    while ((c = getopt(argc, argv, "b:d:l:L:p:Pr:st:vy:")) != EOF && c != -1)
        switch (c)
        {
            default:
                usage(stderr, EXIT_FAILURE);
            case 'b':
                if (strcmp(optarg, "slim") == 0)
                {
                    if (0 < bloat)
                        error(_("incompatible -b options"));
                    bloat = -1;
                }
                else if (strcmp(optarg, "fat") == 0)
                {
                    if (bloat < 0)
                        error(_("incompatible -b options"));
                    bloat = 1;
                }
                else
                    error(_("invalid option: -b '%s'"), optarg);
                break;
            case 'd':
                if (directory == NULL)
                    directory = strdup(optarg);
                else
                {
                    fprintf(stderr,
                            _("%s: More than one -d option specified\n"),
                            progname);
                    return EXIT_FAILURE;
                }
                break;
            case 'l':
                if (lcltime == NULL)
                    lcltime = strdup(optarg);
                else
                {
                    fprintf(stderr,
                            _("%s: More than one -l option specified\n"),
                            progname);
                    return EXIT_FAILURE;
                }
                break;
            case 'p':
                if (psxrules == NULL)
                    psxrules = strdup(optarg);
                else
                {
                    fprintf(stderr,
                            _("%s: More than one -p option specified\n"),
                            progname);
                    return EXIT_FAILURE;
                }
                break;
            case 't':
                if (tzdefault != NULL)
                {
                    fprintf(stderr,
                            _("%s: More than one -t option"
                              " specified\n"),
                            progname);
                    return EXIT_FAILURE;
                }
                tzdefault = optarg;
                break;
            case 'y':
                warning(_("-y ignored"));
                break;
            case 'L':
                if (leapsec == NULL)
                    leapsec = strdup(optarg);
                else
                {
                    fprintf(stderr,
                            _("%s: More than one -L option specified\n"),
                            progname);
                    return EXIT_FAILURE;
                }
                break;
            case 'v':
                noise = true;
                break;
            case 'P':
                print_abbrevs = true;
                print_cutoff = time(NULL);
                break;
            case 'r':
                if (timerange_given)
                {
                    fprintf(stderr,
                            _("%s: More than one -r option specified\n"),
                            progname);
                    return EXIT_FAILURE;
                }
                if (!timerange_option(optarg))
                {
                    fprintf(stderr,
                            _("%s: invalid time range: %s\n"),
                            progname, optarg);
                    return EXIT_FAILURE;
                }
                timerange_given = true;
                break;
            case 's':
                warning(_("-s ignored"));
                break;
        }
    if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
        usage(stderr, EXIT_FAILURE);    /* usage message by request */
    if (bloat == 0)
    {
        static char const bloat_default[] = ZIC_BLOAT_DEFAULT;
 
        if (strcmp(bloat_default, "slim") == 0)
            bloat = -1;
        else if (strcmp(bloat_default, "fat") == 0)
            bloat = 1;
        else
            abort();            /* Configuration error.  */
    }
    if (directory == NULL)
        directory = "data";
    if (tzdefault == NULL)
        tzdefault = TZDEFAULT;
 
    if (optind < argc && leapsec != NULL)
    {
        infile(leapsec);
        adjleap();
    }
 
    for (k = optind; k < argc; k++)
        infile(argv[k]);
    if (errors)
        return EXIT_FAILURE;
    associate();
    change_directory(directory);
    for (i = 0; i < nzones; i = j)
    {
        /*
         * Find the next non-continuation zone entry.
         */
        for (j = i + 1; j < nzones && zones[j].z_name == NULL; ++j)
            continue;
        outzone(&zones[i], j - i);
    }
 
    /*
     * Make links.
     */
    for (i = 0; i < nlinks; ++i)
    {
        eat(links[i].l_filename, links[i].l_linenum);
        dolink(links[i].l_target, links[i].l_linkname, false);
        if (noise)
            for (j = 0; j < nlinks; ++j)
                if (strcmp(links[i].l_linkname,
                           links[j].l_target) == 0)
                    warning(_("link to link"));
    }
    if (lcltime != NULL)
    {
        eat(_("command line"), 1);
        dolink(lcltime, tzdefault, true);
    }
    if (psxrules != NULL)
    {
        eat(_("command line"), 1);
        dolink(psxrules, TZDEFRULES, true);
    }
    if (warnings && (ferror(stderr) || fclose(stderr) != 0))
        return EXIT_FAILURE;
    return errors ? EXIT_FAILURE : EXIT_SUCCESS;
}

References _, adjleap(), associate(), bloat, change_directory(), close_file(), directory, dolink(), eat(), error(), errors, EXIT_FAILURE, EXIT_SUCCESS, fb(), fprintf, getopt(), i, infile(), j, lcltime, leapsec, links, nlinks, noise, nzones, optarg, optind, outzone(), print_abbrevs, print_cutoff, printf, progname, psxrules, S_IWGRP, S_IWOTH, timerange_option(), TYPE_BIT, TZDEFAULT, tzdefault, TZDEFRULES, usage(), warning(), warnings, zone::z_name, ZIC_BLOAT_DEFAULT, and zones.

memcheck()

static void * memcheck ( void *  ptr )

static

Definition at line 444 of file zic.c.

{
    if (ptr == NULL)
        memory_exhausted(strerror(errno));
    return ptr;
}

References fb(), memory_exhausted(), and strerror.

Referenced by ecpyalloc(), emalloc(), and erealloc().

memory_exhausted()

static _Noreturn void memory_exhausted ( const char *  msg )

static

Definition at line 418 of file zic.c.

{
    fprintf(stderr, _("%s: Memory exhausted: %s\n"), progname, msg);
    exit(EXIT_FAILURE);
}

References _, EXIT_FAILURE, fb(), fprintf, and progname.

Referenced by align_to(), growalloc(), memcheck(), and size_product().

mkdirs()

static void mkdirs ( char const *  argname, bool  ancestors  )

static

Definition at line 3955 of file zic.c.

{
    char       *name;
    char       *cp;
 
    cp = name = ecpyalloc(argname);
 
    /*
     * On MS-Windows systems, do not worry about drive letters or backslashes,
     * as this should suffice in practice.  Time zone names do not use drive
     * letters and backslashes.  If the -d option of zic does not name an
     * already-existing directory, it can use slashes to separate the
     * already-existing ancestor prefix from the to-be-created subdirectories.
     */
 
    /* Do not mkdir a root directory, as it must exist.  */
    while (*cp == '/')
        cp++;
 
    while (cp && ((cp = strchr(cp, '/')) || !ancestors))
    {
        if (cp)
            *cp = '\0';
 
        /*
         * Try to create it.  It's OK if creation fails because the directory
         * already exists, perhaps because some other process just created it.
         * For simplicity do not check first whether it already exists, as
         * that is checked anyway if the mkdir fails.
         */
        if (mkdir(name, MKDIR_UMASK) != 0)
        {
            /*
             * For speed, skip itsdir if errno == EEXIST.  Since mkdirs is
             * called only after open fails with ENOENT on a subfile, EEXIST
             * implies itsdir here.
             */
            int         err = errno;
 
            if (err != EEXIST && !itsdir(name))
            {
                error(_("%s: Cannot create directory %s: %s"),
                      progname, name, strerror(err));
                exit(EXIT_FAILURE);
            }
        }
        if (cp)
            *cp++ = '/';
    }
    free(name);
}

References _, ecpyalloc(), err(), error(), EXIT_FAILURE, fb(), free, itsdir(), mkdir, MKDIR_UMASK, name, progname, and strerror.

Referenced by change_directory(), dolink(), and writezone().

namecheck()

static bool namecheck ( const char *  name )

static

Definition at line 929 of file zic.c.

{
    char const *cp;
 
    /* Benign characters in a portable file name.  */
    static char const benign[] =
        "-/_"
        "abcdefghijklmnopqrstuvwxyz"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
    /*
     * Non-control chars in the POSIX portable character set, excluding the
     * benign characters.
     */
    static char const printable_and_not_benign[] =
        " !\"#$%&'()*+,.0123456789:;<=>?@[\\]^`{|}~";
 
    char const *component = name;
 
    for (cp = name; *cp; cp++)
    {
        unsigned char c = *cp;
 
        if (noise && !strchr(benign, c))
        {
            warning((strchr(printable_and_not_benign, c)
                     ? _("file name '%s' contains byte '%c'")
                     : _("file name '%s' contains byte '\\%o'")),
                    name, c);
        }
        if (c == '/')
        {
            if (!componentcheck(name, component, cp))
                return false;
            component = cp + 1;
        }
    }
    return componentcheck(name, component, cp);
}

References _, componentcheck(), fb(), name, noise, and warning().

Referenced by inlink(), and inzsub().

newabbr()

static void newabbr ( const char *  string )

static

Definition at line 3915 of file zic.c.

{
    int         i;
 
    if (strcmp(string, GRANDPARENTED) != 0)
    {
        const char *cp;
        const char *mp;
 
        cp = string;
        mp = NULL;
        while (is_alpha(*cp) || ('0' <= *cp && *cp <= '9')
               || *cp == '-' || *cp == '+')
            ++cp;
        if (noise && cp - string < 3)
            mp = _("time zone abbreviation has fewer than 3 characters");
        if (cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
            mp = _("time zone abbreviation has too many characters");
        if (*cp != '\0')
            mp = _("time zone abbreviation differs from POSIX standard");
        if (mp != NULL)
            warning("%s (%s)", mp, string);
    }
    i = strlen(string) + 1;
    if (charcnt + i > TZ_MAX_CHARS)
    {
        error(_("too many, or too long, time zone abbreviations"));
        exit(EXIT_FAILURE);
    }
    strcpy(&chars[charcnt], string);
    charcnt += i;
}

References _, charcnt, chars, error(), EXIT_FAILURE, fb(), GRANDPARENTED, i, is_alpha(), noise, TZ_MAX_CHARS, warning(), and ZIC_MAX_ABBR_LEN_WO_WARN.

Referenced by addtype().

oadd()

static zic_t oadd ( zic_t  t1, zic_t  t2  )

static

Definition at line 3769 of file zic.c.

{
    if (t1 < 0 ? t2 < ZIC_MIN - t1 : ZIC_MAX - t1 < t2)
        time_overflow();
    return t1 + t2;
}

References fb(), time_overflow(), ZIC_MAX, and ZIC_MIN.

Referenced by adjleap(), gethms(), getleapdatetime(), outzone(), and rpytime().

outzone()

static void outzone ( const struct zone *  zpfirst, ptrdiff_t  zonecount  )

static

Definition at line 2949 of file zic.c.

{
    const struct zone *zp;
    struct rule *rp;
    ptrdiff_t   i,
                j;
    bool        usestart,
                useuntil;
    zic_t       starttime,
                untiltime;
    zic_t       stdoff;
    zic_t       save;
    zic_t       year;
    zic_t       startoff;
    bool        startttisstd;
    bool        startttisut;
    int         type;
    char       *startbuf;
    char       *ab;
    char       *envvar;
    int         max_abbr_len;
    int         max_envvar_len;
    bool        prodstic;       /* all rules are min to max */
    int         compat;
    bool        do_extend;
    char        version;
    ptrdiff_t   lastatmax = -1;
    zic_t       one = 1;
    zic_t       y2038_boundary = one << 31;
    zic_t       max_year0;
    int         defaulttype = -1;
 
    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;
    charcnt = 0;
    prodstic = zonecount == 1;
 
    /*
     * Thanks to Earl Chew for noting the need to unconditionally initialize
     * startttisstd.
     */
    startttisstd = false;
    startttisut = false;
    min_year = max_year = EPOCH_YEAR;
    if (leapseen)
    {
        updateminmax(leapminyear);
        updateminmax(leapmaxyear + (leapmaxyear < ZIC_MAX));
    }
    for (i = 0; i < zonecount; ++i)
    {
        zp = &zpfirst[i];
        if (i < zonecount - 1)
            updateminmax(zp->z_untilrule.r_loyear);
        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.
     */
    compat = stringzone(envvar, zpfirst, zonecount);
    version = compat < 2013 ? ZIC_VERSION_PRE_2013 : ZIC_VERSION;
    do_extend = compat < 0;
    if (noise)
    {
        if (!*envvar)
            warning("%s %s",
                    _("no POSIX environment variable for zone"),
                    zpfirst->z_name);
        else if (compat != 0)
        {
            /*
             * Circa-COMPAT clients, and earlier clients, might not work for
             * this zone when given dates before 1970 or after 2038.
             */
            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 - years_of_observations)
            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 + years_of_observations;
        }
    }
    max_year0 = max_year;
    if (want_bloat())
    {
        /*
         * For the benefit of older systems, generate data from 1900 through
         * 2038.
         */
        if (min_year > 1900)
            min_year = 1900;
        if (max_year < 2038)
            max_year = 2038;
    }
 
    for (i = 0; i < zonecount; ++i)
    {
        struct rule *prevrp = NULL;
 
        /*
         * A guess that may well be corrected later.
         */
        save = 0;
        zp = &zpfirst[i];
        usestart = i > 0 && (zp - 1)->z_untiltime > min_time;
        useuntil = i < (zonecount - 1);
        if (useuntil && zp->z_untiltime <= min_time)
            continue;
        stdoff = zp->z_stdoff;
        eat(zp->z_filename, zp->z_linenum);
        *startbuf = '\0';
        startoff = zp->z_stdoff;
        if (zp->z_nrules == 0)
        {
            save = zp->z_save;
            doabbr(startbuf, zp, NULL, zp->z_isdst, save, false);
            type = addtype(oadd(zp->z_stdoff, save),
                           startbuf, zp->z_isdst, startttisstd,
                           startttisut);
            if (usestart)
            {
                addtt(starttime, type);
                usestart = false;
            }
            else
                defaulttype = type;
        }
        else
            for (year = min_year; year <= max_year; ++year)
            {
                if (useuntil && year > zp->z_untilrule.r_hiyear)
                    break;
 
                /*
                 * Mark which rules to do in the current year. For those to
                 * do, calculate rpytime(rp, year); The former TYPE field was
                 * also considered here.
                 */
                for (j = 0; j < zp->z_nrules; ++j)
                {
                    rp = &zp->z_rules[j];
                    eats(zp->z_filename, zp->z_linenum,
                         rp->r_filename, rp->r_linenum);
                    rp->r_todo = year >= rp->r_loyear &&
                        year <= rp->r_hiyear;
                    if (rp->r_todo)
                    {
                        rp->r_temp = rpytime(rp, year);
                        rp->r_todo
                            = (rp->r_temp < y2038_boundary
                               || year <= max_year0);
                    }
                }
                for (;;)
                {
                    ptrdiff_t   k;
                    zic_t       jtime,
                                ktime;
                    zic_t       offset;
 
                    INITIALIZE(ktime);
                    if (useuntil)
                    {
                        /*
                         * Turn untiltime into UT assuming the current stdoff
                         * and save values.
                         */
                        untiltime = zp->z_untiltime;
                        if (!zp->z_untilrule.r_todisut)
                            untiltime = tadd(untiltime,
                                             -stdoff);
                        if (!zp->z_untilrule.r_todisstd)
                            untiltime = tadd(untiltime,
                                             -save);
                    }
 
                    /*
                     * Find the rule (of those to do, if any) that takes
                     * effect earliest in the year.
                     */
                    k = -1;
                    for (j = 0; j < zp->z_nrules; ++j)
                    {
                        rp = &zp->z_rules[j];
                        if (!rp->r_todo)
                            continue;
                        eats(zp->z_filename, zp->z_linenum,
                             rp->r_filename, rp->r_linenum);
                        offset = rp->r_todisut ? 0 : stdoff;
                        if (!rp->r_todisstd)
                            offset = oadd(offset, save);
                        jtime = rp->r_temp;
                        if (jtime == min_time ||
                            jtime == max_time)
                            continue;
                        jtime = tadd(jtime, -offset);
                        if (k < 0 || jtime < ktime)
                        {
                            k = j;
                            ktime = jtime;
                        }
                        else if (jtime == ktime)
                        {
                            char const *dup_rules_msg =
                                _("two rules for same instant");
 
                            eats(zp->z_filename, zp->z_linenum,
                                 rp->r_filename, rp->r_linenum);
                            warning("%s", dup_rules_msg);
                            rp = &zp->z_rules[k];
                            eats(zp->z_filename, zp->z_linenum,
                                 rp->r_filename, rp->r_linenum);
                            error("%s", dup_rules_msg);
                        }
                    }
                    if (k < 0)
                        break;  /* go on to next year */
                    rp = &zp->z_rules[k];
                    rp->r_todo = false;
                    if (useuntil && ktime >= untiltime)
                        break;
                    save = rp->r_save;
                    if (usestart && ktime == starttime)
                        usestart = false;
                    if (usestart)
                    {
                        if (ktime < starttime)
                        {
                            startoff = oadd(zp->z_stdoff,
                                            save);
                            doabbr(startbuf, zp,
                                   rp->r_abbrvar,
                                   rp->r_isdst,
                                   rp->r_save,
                                   false);
                            continue;
                        }
                        if (*startbuf == '\0'
                            && startoff == oadd(zp->z_stdoff,
                                                save))
                        {
                            doabbr(startbuf,
                                   zp,
                                   rp->r_abbrvar,
                                   rp->r_isdst,
                                   rp->r_save,
                                   false);
                        }
                    }
                    eats(zp->z_filename, zp->z_linenum,
                         rp->r_filename, rp->r_linenum);
                    doabbr(ab, zp, rp->r_abbrvar,
                           rp->r_isdst, rp->r_save, false);
                    offset = oadd(zp->z_stdoff, rp->r_save);
                    if (!want_bloat() && !useuntil && !do_extend
                        && prevrp
                        && rp->r_hiyear == ZIC_MAX
                        && prevrp->r_hiyear == ZIC_MAX)
                        break;
                    type = addtype(offset, ab, rp->r_isdst,
                                   rp->r_todisstd, rp->r_todisut);
                    if (defaulttype < 0 && !rp->r_isdst)
                        defaulttype = type;
                    if (rp->r_hiyear == ZIC_MAX
                        && !(0 <= lastatmax
                             && ktime < attypes[lastatmax].at))
                        lastatmax = timecnt;
                    addtt(ktime, type);
                    prevrp = rp;
                }
            }
        if (usestart)
        {
            if (*startbuf == '\0' &&
                zp->z_format != NULL &&
                strchr(zp->z_format, '%') == NULL &&
                strchr(zp->z_format, '/') == NULL)
                strcpy(startbuf, zp->z_format);
            eat(zp->z_filename, zp->z_linenum);
            if (*startbuf == '\0')
                error(_("cannot determine time zone abbreviation to use just after until time"));
            else
            {
                bool        isdst = startoff != zp->z_stdoff;
 
                type = addtype(startoff, startbuf, isdst,
                               startttisstd, startttisut);
                if (defaulttype < 0 && !isdst)
                    defaulttype = type;
                addtt(starttime, type);
            }
        }
 
        /*
         * Now we may get to set starttime for the next zone line.
         */
        if (useuntil)
        {
            startttisstd = zp->z_untilrule.r_todisstd;
            startttisut = zp->z_untilrule.r_todisut;
            starttime = zp->z_untiltime;
            if (!startttisstd)
                starttime = tadd(starttime, -save);
            if (!startttisut)
                starttime = tadd(starttime, -stdoff);
        }
    }
    if (defaulttype < 0)
        defaulttype = 0;
    if (0 <= lastatmax)
        attypes[lastatmax].dontmerge = true;
    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, i = 1; i < timecnt; i++)
            if (attypes[i].at > lastat->at)
                lastat = &attypes[i];
        if (!lastat || lastat->at < rpytime(&xr, max_year - 1))
        {
            addtt(rpytime(&xr, max_year + 1),
                  lastat ? lastat->type : defaulttype);
            attypes[timecnt - 1].dontmerge = true;
        }
    }
    writezone(zpfirst->z_name, envvar, version, defaulttype);
    free(startbuf);
    free(ab);
    free(envvar);
}

References _, addtt(), addtype(), attype::at, attypes, charcnt, compat, DC_DOM, doabbr(), attype::dontmerge, eat(), eats(), emalloc(), EPOCH_YEAR, error(), fb(), free, i, INITIALIZE, j, leapmaxyear, leapminyear, leapseen, max_abbrvar_len, max_format_len, max_time, max_year, min_time, min_year, noise, oadd(), rule::r_isdst, rpytime(), stringzone(), tadd(), timecnt, TM_JANUARY, type, typecnt, updateminmax(), want_bloat(), warning(), writezone(), YEARSPERREPEAT, ZIC_MAX, ZIC_MIN, ZIC_VERSION, and ZIC_VERSION_PRE_2013.

Referenced by main().

puttzcode()

static void puttzcode ( const int_fast32_t  val, FILE *const  fp  )

static

Definition at line 2016 of file zic.c.

{
    char        buf[4];
 
    convert(val, buf);
    fwrite(buf, sizeof buf, 1, fp);
}

References buf, convert(), fb(), and val.

Referenced by puttzcodepass(), and writezone().

puttzcodepass()

static void puttzcodepass ( zic_t  val, FILE *  fp, int  pass  )

static

Definition at line 2025 of file zic.c.

{
    if (pass == 1)
        puttzcode(val, fp);
    else
    {
        char        buf[8];
 
        convert64(val, buf);
        fwrite(buf, sizeof buf, 1, fp);
    }
}

References buf, convert64(), fb(), puttzcode(), and val.

Referenced by writezone().

rcomp()

static int rcomp ( const void *  cp1, const void *  cp2  )

static

Definition at line 1179 of file zic.c.

{
    return strcmp(((const struct rule *) cp1)->r_name,
                  ((const struct rule *) cp2)->r_name);
}

References fb().

Referenced by associate().

relname()

static char * relname ( char const *  target, char const *  linkname  )

static

Definition at line 977 of file zic.c.

{
    size_t      i,
                taillen,
                dotdotetcsize;
    size_t      dir_len = 0,
                dotdots = 0,
                linksize = SIZE_MAX;
    char const *f = target;
    char       *result = NULL;
 
    if (*linkname == '/')
    {
        /* Make F absolute too.  */
        size_t      len = strlen(directory);
        bool        needslash = len && directory[len - 1] != '/';
 
        linksize = len + needslash + strlen(target) + 1;
        f = result = emalloc(linksize);
        strcpy(result, directory);
        result[len] = '/';
        strcpy(result + len + needslash, target);
    }
    for (i = 0; f[i] && f[i] == linkname[i]; i++)
        if (f[i] == '/')
            dir_len = i + 1;
    for (; linkname[i]; i++)
        dotdots += linkname[i] == '/' && linkname[i - 1] != '/';
    taillen = strlen(f + dir_len);
    dotdotetcsize = 3 * dotdots + taillen + 1;
    if (dotdotetcsize <= linksize)
    {
        if (!result)
            result = emalloc(dotdotetcsize);
        for (i = 0; i < dotdots; i++)
            memcpy(result + 3 * i, "../", 3);
        memmove(result + 3 * dotdots, f + dir_len, taillen + 1);
    }
    return result;
}

References directory, emalloc(), fb(), i, len, memcpy(), and result.

rpytime()

static zic_t rpytime ( const struct rule *  rp, zic_t  wantedy  )

static

Definition at line 3806 of file zic.c.

{
    int         m,
                i;
    zic_t       dayoff;         /* with a nod to Margaret O. */
    zic_t       t,
                y;
 
    if (wantedy == ZIC_MIN)
        return min_time;
    if (wantedy == ZIC_MAX)
        return max_time;
    dayoff = 0;
    m = TM_JANUARY;
    y = EPOCH_YEAR;
    if (y < wantedy)
    {
        wantedy -= y;
        dayoff = (wantedy / YEARSPERREPEAT) * (SECSPERREPEAT / SECSPERDAY);
        wantedy %= YEARSPERREPEAT;
        wantedy += y;
    }
    else if (wantedy < 0)
    {
        dayoff = (wantedy / YEARSPERREPEAT) * (SECSPERREPEAT / SECSPERDAY);
        wantedy %= YEARSPERREPEAT;
    }
    while (wantedy != y)
    {
        if (wantedy > y)
        {
            i = len_years[isleap(y)];
            ++y;
        }
        else
        {
            --y;
            i = -len_years[isleap(y)];
        }
        dayoff = oadd(dayoff, i);
    }
    while (m != rp->r_month)
    {
        i = len_months[isleap(y)][m];
        dayoff = oadd(dayoff, i);
        ++m;
    }
    i = rp->r_dayofmonth;
    if (m == TM_FEBRUARY && i == 29 && !isleap(y))
    {
        if (rp->r_dycode == DC_DOWLEQ)
            --i;
        else
        {
            error(_("use of 2/29 in non leap-year"));
            exit(EXIT_FAILURE);
        }
    }
    --i;
    dayoff = oadd(dayoff, i);
    if (rp->r_dycode == DC_DOWGEQ || rp->r_dycode == DC_DOWLEQ)
    {
        zic_t       wday;
 
#define LDAYSPERWEEK    ((zic_t) DAYSPERWEEK)
        wday = EPOCH_WDAY;
 
        /*
         * Don't trust mod of negative numbers.
         */
        if (dayoff >= 0)
            wday = (wday + dayoff) % LDAYSPERWEEK;
        else
        {
            wday -= ((-dayoff) % LDAYSPERWEEK);
            if (wday < 0)
                wday += LDAYSPERWEEK;
        }
        while (wday != rp->r_wday)
            if (rp->r_dycode == DC_DOWGEQ)
            {
                dayoff = oadd(dayoff, 1);
                if (++wday >= LDAYSPERWEEK)
                    wday = 0;
                ++i;
            }
            else
            {
                dayoff = oadd(dayoff, -1);
                if (--wday < 0)
                    wday = LDAYSPERWEEK - 1;
                --i;
            }
        if (i < 0 || i >= len_months[isleap(y)][m])
        {
            if (noise)
                warning(_("rule goes past start/end of month; \
will not work with pre-2004 versions of zic"));
        }
    }
    if (dayoff < min_time / SECSPERDAY)
        return min_time;
    if (dayoff > max_time / SECSPERDAY)
        return max_time;
    t = (zic_t) dayoff * SECSPERDAY;
    return tadd(t, rp->r_tod);
}

References _, DC_DOWGEQ, DC_DOWLEQ, EPOCH_WDAY, EPOCH_YEAR, error(), EXIT_FAILURE, fb(), i, isleap, LDAYSPERWEEK, len_months, len_years, max_time, min_time, noise, oadd(), SECSPERDAY, SECSPERREPEAT, tadd(), TM_FEBRUARY, TM_JANUARY, warning(), y, YEARSPERREPEAT, ZIC_MAX, and ZIC_MIN.

Referenced by inzsub(), and outzone().

rule_cmp()

static int rule_cmp ( struct rule const *  a, struct rule const *  b  )

static

Definition at line 2800 of file zic.c.

{
    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;
}

References a, and b.

Referenced by stringzone().

rulesub()

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

Definition at line 1832 of file zic.c.

{
    const struct lookup *lp;
    const char *cp;
    char       *dp;
    char       *ep;
    char        xs;
 
    if ((lp = byword(monthp, mon_names)) == NULL)
    {
        error(_("invalid month name"));
        return;
    }
    rp->r_month = lp->l_value;
    rp->r_todisstd = false;
    rp->r_todisut = false;
    dp = ecpyalloc(timep);
    if (*dp != '\0')
    {
        ep = dp + strlen(dp) - 1;
        switch (lowerit(*ep))
        {
            case 's':           /* Standard */
                rp->r_todisstd = true;
                rp->r_todisut = false;
                *ep = '\0';
                break;
            case 'w':           /* Wall */
                rp->r_todisstd = false;
                rp->r_todisut = false;
                *ep = '\0';
                break;
            case 'g':           /* Greenwich */
            case 'u':           /* Universal */
            case 'z':           /* Zulu */
                rp->r_todisstd = true;
                rp->r_todisut = true;
                *ep = '\0';
                break;
        }
    }
    rp->r_tod = gethms(dp, _("invalid time of day"));
    free(dp);
 
    /*
     * Year work.
     */
    cp = loyearp;
    lp = byword(cp, begin_years);
    rp->r_lowasnum = lp == NULL;
    if (!rp->r_lowasnum)
        switch (lp->l_value)
        {
            case YR_MINIMUM:
                rp->r_loyear = ZIC_MIN;
                break;
            case YR_MAXIMUM:
                rp->r_loyear = ZIC_MAX;
                break;
            default:            /* "cannot happen" */
                fprintf(stderr,
                        _("%s: panic: Invalid l_value %d\n"),
                        progname, lp->l_value);
                exit(EXIT_FAILURE);
        }
    else if (sscanf(cp, "%" SCNdZIC "%c", &rp->r_loyear, &xs) != 1)
    {
        error(_("invalid starting year"));
        return;
    }
    cp = hiyearp;
    lp = byword(cp, end_years);
    rp->r_hiwasnum = lp == NULL;
    if (!rp->r_hiwasnum)
        switch (lp->l_value)
        {
            case YR_MINIMUM:
                rp->r_hiyear = ZIC_MIN;
                break;
            case YR_MAXIMUM:
                rp->r_hiyear = ZIC_MAX;
                break;
            case YR_ONLY:
                rp->r_hiyear = rp->r_loyear;
                break;
            default:            /* "cannot happen" */
                fprintf(stderr,
                        _("%s: panic: Invalid l_value %d\n"),
                        progname, lp->l_value);
                exit(EXIT_FAILURE);
        }
    else if (sscanf(cp, "%" SCNdZIC "%c", &rp->r_hiyear, &xs) != 1)
    {
        error(_("invalid ending year"));
        return;
    }
    if (rp->r_loyear > rp->r_hiyear)
    {
        error(_("starting year greater than ending year"));
        return;
    }
    if (*typep != '\0')
    {
        error(_("year type \"%s\" is unsupported; use \"-\" instead"),
              typep);
        return;
    }
 
    /*
     * Day work. Accept things such as: 1 lastSunday last-Sunday
     * (undocumented; warn about this) Sun<=20 Sun>=7
     */
    dp = ecpyalloc(dayp);
    if ((lp = byword(dp, lasts)) != NULL)
    {
        rp->r_dycode = DC_DOWLEQ;
        rp->r_wday = lp->l_value;
        rp->r_dayofmonth = len_months[1][rp->r_month];
    }
    else
    {
        if ((ep = strchr(dp, '<')) != NULL)
            rp->r_dycode = DC_DOWLEQ;
        else if ((ep = strchr(dp, '>')) != NULL)
            rp->r_dycode = DC_DOWGEQ;
        else
        {
            ep = dp;
            rp->r_dycode = DC_DOM;
        }
        if (rp->r_dycode != DC_DOM)
        {
            *ep++ = 0;
            if (*ep++ != '=')
            {
                error(_("invalid day of month"));
                free(dp);
                return;
            }
            if ((lp = byword(dp, wday_names)) == NULL)
            {
                error(_("invalid weekday name"));
                free(dp);
                return;
            }
            rp->r_wday = lp->l_value;
        }
        if (sscanf(ep, "%d%c", &rp->r_dayofmonth, &xs) != 1 ||
            rp->r_dayofmonth <= 0 ||
            (rp->r_dayofmonth > len_months[1][rp->r_month]))
        {
            error(_("invalid day of month"));
            free(dp);
            return;
        }
    }
    free(dp);
}

References _, begin_years, byword(), DC_DOM, DC_DOWGEQ, DC_DOWLEQ, ecpyalloc(), end_years, error(), EXIT_FAILURE, fb(), fprintf, free, gethms(), lasts, len_months, lowerit(), mon_names, progname, SCNdZIC, wday_names, YR_MAXIMUM, YR_MINIMUM, YR_ONLY, ZIC_MAX, and ZIC_MIN.

Referenced by inrule(), and inzsub().

size_product()

static size_t size_product ( size_t  nitems, size_t  itemsize  )

static

Definition at line 425 of file zic.c.

{
    if (SIZE_MAX / itemsize < nitems)
        memory_exhausted(_("size overflow"));
    return nitems * itemsize;
}

References _, fb(), memory_exhausted(), and nitems.

Referenced by getfields(), growalloc(), and writezone().

stringoffset()

static int stringoffset ( char *  result, zic_t  offset  )

static

Definition at line 2685 of file zic.c.

{
    int         hours;
    int         minutes;
    int         seconds;
    bool        negative = offset < 0;
    int         len = negative;
 
    if (negative)
    {
        offset = -offset;
        result[0] = '-';
    }
    seconds = offset % SECSPERMIN;
    offset /= SECSPERMIN;
    minutes = offset % MINSPERHOUR;
    offset /= MINSPERHOUR;
    hours = offset;
    if (hours >= HOURSPERDAY * DAYSPERWEEK)
    {
        result[0] = '\0';
        return 0;
    }
    len += sprintf(result + len, "%d", hours);
    if (minutes != 0 || seconds != 0)
    {
        len += sprintf(result + len, ":%02d", minutes);
        if (seconds != 0)
            len += sprintf(result + len, ":%02d", seconds);
    }
    return len;
}

References DAYSPERWEEK, fb(), HOURSPERDAY, len, MINSPERHOUR, result, SECSPERMIN, and sprintf.

Referenced by stringrule(), and stringzone().

stringrule()

static int stringrule ( char *  result, struct rule *const  rp, zic_t  save, zic_t  stdoff  )

static

Definition at line 2719 of file zic.c.

{
    zic_t       tod = rp->r_tod;
    int         compat = 0;
 
    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];
        /* Omit the "J" in Jan and Feb, as that's shorter.  */
        if (rp->r_month <= 1)
            result += sprintf(result, "%d", total + rp->r_dayofmonth - 1);
        else
            result += sprintf(result, "J%d", total + rp->r_dayofmonth);
    }
    else
    {
        int         week;
        int         wday = rp->r_wday;
        int         wdayoff;
 
        if (rp->r_dycode == DC_DOWGEQ)
        {
            wdayoff = (rp->r_dayofmonth - 1) % DAYSPERWEEK;
            if (wdayoff)
                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
            {
                wdayoff = rp->r_dayofmonth % DAYSPERWEEK;
                if (wdayoff)
                    compat = 2013;
                wday -= wdayoff;
                tod += wdayoff * SECSPERDAY;
                week = rp->r_dayofmonth / DAYSPERWEEK;
            }
        }
        else
            return -1;          /* "cannot happen" */
        if (wday < 0)
            wday += DAYSPERWEEK;
        result += sprintf(result, "M%d.%d.%d",
                          rp->r_month + 1, week, wday);
    }
    if (rp->r_todisut)
        tod += stdoff;
    if (rp->r_todisstd && !rp->r_isdst)
        tod += save;
    if (tod != 2 * SECSPERMIN * MINSPERHOUR)
    {
        *result++ = '/';
        if (!stringoffset(result, tod))
            return -1;
        if (tod < 0)
        {
            if (compat < 2013)
                compat = 2013;
        }
        else if (SECSPERDAY <= tod)
        {
            if (compat < 1994)
                compat = 1994;
        }
    }
    return compat;
}

References compat, DAYSPERWEEK, DC_DOM, DC_DOWGEQ, DC_DOWLEQ, fb(), len_months, MINSPERHOUR, result, SECSPERDAY, SECSPERMIN, sprintf, stringoffset(), and TM_FEBRUARY.

Referenced by stringzone().

stringzone()

static int stringzone ( char *  result, struct zone const *  zpfirst, ptrdiff_t  zonecount  )

static

Definition at line 2814 of file zic.c.

{
    const struct zone *zp;
    struct rule *rp;
    struct rule *stdrp;
    struct rule *dstrp;
    ptrdiff_t   i;
    const char *abbrvar;
    int         compat = 0;
    int         c;
    size_t      len;
    int         offsetlen;
    struct rule stdr,
                dstr;
 
    result[0] = '\0';
 
    /*
     * Internet RFC 8536 section 5.1 says to use an empty TZ string if future
     * timestamps are truncated.
     */
    if (hi_time < max_time)
        return -1;
 
    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_isdst)
        {
            if (stdrp == NULL)
                stdrp = rp;
            else
                return -1;
        }
        else
        {
            if (dstrp == NULL)
                dstrp = rp;
            else
                return -1;
        }
    }
    if (stdrp == NULL && dstrp == NULL)
    {
        /*
         * There are no rules running through "max". 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 (!rp->r_isdst && rule_cmp(stdabbrrp, rp) < 0)
                stdabbrrp = rp;
            if (rule_cmp(stdrp, rp) < 0)
                stdrp = rp;
        }
        if (stdrp != NULL && stdrp->r_isdst)
        {
            /* 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_todisut = false;
            dstr.r_isdst = stdrp->r_isdst;
            dstr.r_save = stdrp->r_save;
            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_save;
            stdr.r_todisstd = stdr.r_todisut = false;
            stdr.r_isdst = false;
            stdr.r_save = 0;
            stdr.r_abbrvar
                = (stdabbrrp ? stdabbrrp->r_abbrvar : "");
            dstrp = &dstr;
            stdrp = &stdr;
        }
    }
    if (stdrp == NULL && (zp->z_nrules != 0 || zp->z_isdst))
        return -1;
    abbrvar = (stdrp == NULL) ? "" : stdrp->r_abbrvar;
    len = doabbr(result, zp, abbrvar, false, 0, true);
    offsetlen = stringoffset(result + len, -zp->z_stdoff);
    if (!offsetlen)
    {
        result[0] = '\0';
        return -1;
    }
    len += offsetlen;
    if (dstrp == NULL)
        return compat;
    len += doabbr(result + len, zp, dstrp->r_abbrvar,
                  dstrp->r_isdst, dstrp->r_save, true);
    if (dstrp->r_save != SECSPERMIN * MINSPERHOUR)
    {
        offsetlen = stringoffset(result + len,
                                 -(zp->z_stdoff + dstrp->r_save));
        if (!offsetlen)
        {
            result[0] = '\0';
            return -1;
        }
        len += offsetlen;
    }
    result[len++] = ',';
    c = stringrule(result + len, dstrp, dstrp->r_save, zp->z_stdoff);
    if (c < 0)
    {
        result[0] = '\0';
        return -1;
    }
    if (compat < c)
        compat = c;
    len += strlen(result + len);
    result[len++] = ',';
    c = stringrule(result + len, stdrp, dstrp->r_save, zp->z_stdoff);
    if (c < 0)
    {
        result[0] = '\0';
        return -1;
    }
    if (compat < c)
        compat = c;
    return compat;
}

References compat, DC_DOM, doabbr(), fb(), hi_time, i, len, max_time, MINSPERHOUR, rule::r_month, result, rule_cmp(), SECSPERDAY, SECSPERMIN, stringoffset(), stringrule(), TM_DECEMBER, TM_JANUARY, and ZIC_MAX.

Referenced by outzone().

tadd()

static zic_t tadd ( zic_t  t1, zic_t  t2  )

static

Definition at line 3777 of file zic.c.

{
    if (t1 < 0)
    {
        if (t2 < min_time - t1)
        {
            if (t1 != min_time)
                time_overflow();
            return min_time;
        }
    }
    else
    {
        if (max_time - t1 < t2)
        {
            if (t1 != max_time)
                time_overflow();
            return max_time;
        }
    }
    return t1 + t2;
}

References fb(), max_time, min_time, and time_overflow().

Referenced by adjleap(), getleapdatetime(), outzone(), rpytime(), and writezone().

time_overflow()

static _Noreturn void time_overflow ( void  )

static

Definition at line 3762 of file zic.c.

{
    error(_("time overflow"));
    exit(EXIT_FAILURE);
}

References _, error(), EXIT_FAILURE, and fb().

Referenced by oadd(), and tadd().

timerange_option()

static bool timerange_option ( char *  timerange )

static

Definition at line 626 of file zic.c.

{
    intmax_t    lo = min_time,
                hi = max_time;
    char       *lo_end = timerange,
               *hi_end;
 
    if (*timerange == '@')
    {
        errno = 0;
        lo = strtoimax(timerange + 1, &lo_end, 10);
        if (lo_end == timerange + 1 || (lo == INTMAX_MAX && errno == ERANGE))
            return false;
    }
    hi_end = lo_end;
    if (lo_end[0] == '/' && lo_end[1] == '@')
    {
        errno = 0;
        hi = strtoimax(lo_end + 2, &hi_end, 10);
        if (hi_end == lo_end + 2 || hi == INTMAX_MIN)
            return false;
        hi -= !(hi == INTMAX_MAX && errno == ERANGE);
    }
    if (*hi_end || hi < lo || max_time < lo || hi < min_time)
        return false;
    lo_time = lo < min_time ? min_time : lo;
    hi_time = max_time < hi ? max_time : hi;
    return true;
}

References fb(), hi_time, lo_time, max_time, and min_time.

Referenced by main().

updateminmax()

static void updateminmax ( const zic_t  x )

static

Definition at line 2676 of file zic.c.

{
    if (min_year > x)
        min_year = x;
    if (max_year < x)
        max_year = x;
}

References max_year, min_year, and x.

Referenced by outzone().

usage()

static _Noreturn void usage ( FILE *  stream, int  status  )

static

Definition at line 561 of file zic.c.

{
    fprintf(stream,
            _("%s: usage is %s [ --version ] [ --help ] [ -v ] [ -P ] \\\n"
              "\t[ -b {slim|fat} ] [ -d directory ] [ -l localtime ]"
              " [ -L leapseconds ] \\\n"
              "\t[ -p posixrules ] [ -r '[@lo][/@hi]' ] [ -t localtime-link ] \\\n"
              "\t[ filename ... ]\n\n"
              "Report bugs to %s.\n"),
            progname, progname, PACKAGE_BUGREPORT);
    if (status == EXIT_SUCCESS)
        close_file(stream, NULL, NULL);
    exit(status);
}

References _, close_file(), EXIT_SUCCESS, fb(), fprintf, and progname.

verror()

static void verror ( const char *const  string, va_list  args  )

static

Definition at line 506 of file zic.c.

{
    /*
     * Match the format of "cc" to allow sh users to zic ... 2>&1 | error -t
     * "*" -v on BSD systems.
     */
    if (filename)
        fprintf(stderr, _("\"%s\", line %" PRIdMAX ": "), filename, linenum);
    vfprintf(stderr, string, args);
    if (rfilename != NULL)
        fprintf(stderr, _(" (rule from \"%s\", line %" PRIdMAX ")"),
                rfilename, rlinenum);
    fprintf(stderr, "\n");
}

References _, fb(), filename, fprintf, linenum, rfilename, rlinenum, and vfprintf.

Referenced by error(), and warning().

want_bloat()

static bool want_bloat ( void  )

static

Definition at line 670 of file zic.c.

{
    return 0 <= bloat;
}

References bloat.

Referenced by addtype(), outzone(), and writezone().

warning()

static void warning ( const char *const  string,   ...  )

static

Definition at line 533 of file zic.c.

{
    va_list     args;
 
    fprintf(stderr, _("warning: "));
    va_start(args, string);
    verror(string, args);
    va_end(args);
    warnings = true;
}

References _, fb(), fprintf, verror(), and warnings.

Referenced by adjleap(), associate(), byword(), componentcheck(), dolink(), get_role_password(), gethms(), inzsub(), main(), md5_crypt_verify(), namecheck(), newabbr(), outzone(), rpytime(), and writezone().

writezone()

static void writezone ( const char *const  name, const char *const  string, char  version, int  defaulttype  )

static

Definition at line 2084 of file zic.c.

{
    FILE       *fp;
    ptrdiff_t   i,
                j;
    int         pass;
    static const struct tzhead tzh0;
    static struct tzhead tzh;
    bool        dir_checked = false;
    zic_t       one = 1;
    zic_t       y2038_boundary = one << 31;
    ptrdiff_t   nats = timecnt + WORK_AROUND_QTBUG_53071;
 
    /*
     * Allocate the ATS and TYPES arrays via a single malloc, as this is a bit
     * faster.
     */
    zic_t      *ats = emalloc(align_to(size_product(nats, sizeof *ats + 1),
                                       _Alignof(zic_t)));
    void       *typesptr = ats + nats;
    unsigned char *types = typesptr;
    struct timerange rangeall,
                range32,
                range64;
 
    /*
     * Sort.
     */
    if (timecnt > 1)
        qsort(attypes, timecnt, sizeof *attypes, atcomp);
 
    /*
     * Optimize.
     */
    {
        ptrdiff_t   fromi,
                    toi;
 
        toi = 0;
        fromi = 0;
        for (; fromi < timecnt; ++fromi)
        {
            if (toi != 0
                && ((attypes[fromi].at
                     + utoffs[attypes[toi - 1].type])
                    <= (attypes[toi - 1].at
                        + utoffs[toi == 1 ? 0
                                 : attypes[toi - 2].type])))
            {
                attypes[toi - 1].type =
                    attypes[fromi].type;
                continue;
            }
            if (toi == 0
                || attypes[fromi].dontmerge
                || (utoffs[attypes[toi - 1].type]
                    != utoffs[attypes[fromi].type])
                || (isdsts[attypes[toi - 1].type]
                    != isdsts[attypes[fromi].type])
                || (desigidx[attypes[toi - 1].type]
                    != desigidx[attypes[fromi].type]))
                attypes[toi++] = attypes[fromi];
        }
        timecnt = toi;
    }
 
    if (noise && timecnt > 1200)
    {
        if (timecnt > TZ_MAX_TIMES)
            warning(_("reference clients mishandle"
                      " more than %d transition times"),
                    TZ_MAX_TIMES);
        else
            warning(_("pre-2014 clients may mishandle"
                      " more than 1200 transition times"));
    }
 
    /*
     * Transfer.
     */
    for (i = 0; i < timecnt; ++i)
    {
        ats[i] = attypes[i].at;
        types[i] = attypes[i].type;
    }
 
    /*
     * Correct for leap seconds.
     */
    for (i = 0; i < timecnt; ++i)
    {
        j = leapcnt;
        while (--j >= 0)
            if (ats[i] > trans[j] - corr[j])
            {
                ats[i] = tadd(ats[i], corr[j]);
                break;
            }
    }
 
    /*
     * Work around QTBUG-53071 for timestamps less than y2038_boundary - 1, by
     * inserting a no-op transition at time y2038_boundary - 1. This works
     * only for timestamps before the boundary, which should be good enough in
     * practice as QTBUG-53071 should be long-dead by 2038.  Do this after
     * correcting for leap seconds, as the idea is to insert a transition just
     * before 32-bit pg_time_t rolls around, and this occurs at a slightly
     * different moment if transitions are leap-second corrected.
     */
    if (WORK_AROUND_QTBUG_53071 && timecnt != 0 && want_bloat()
        && ats[timecnt - 1] < y2038_boundary - 1 && strchr(string, '<'))
    {
        ats[timecnt] = y2038_boundary - 1;
        types[timecnt] = types[timecnt - 1];
        timecnt++;
    }
 
    rangeall.defaulttype = defaulttype;
    rangeall.base = rangeall.leapbase = 0;
    rangeall.count = timecnt;
    rangeall.leapcount = leapcnt;
    range64 = limitrange(rangeall, lo_time, hi_time, ats, types);
    range32 = limitrange(range64, INT32_MIN, INT32_MAX, ats, types);
 
    /*
     * Remove old file, if any, to snap links.
     */
    if (remove(name) == 0)
        dir_checked = true;
    else if (errno != ENOENT)
    {
        const char *e = strerror(errno);
 
        fprintf(stderr, _("%s: Cannot remove %s/%s: %s\n"),
                progname, directory, name, e);
        exit(EXIT_FAILURE);
    }
    fp = fopen(name, "wb");
    if (!fp)
    {
        int         fopen_errno = errno;
 
        if (fopen_errno == ENOENT && !dir_checked)
        {
            mkdirs(name, true);
            fp = fopen(name, "wb");
            fopen_errno = errno;
        }
        if (!fp)
        {
            fprintf(stderr, _("%s: Cannot create %s/%s: %s\n"),
                    progname, directory, name, strerror(fopen_errno));
            exit(EXIT_FAILURE);
        }
    }
    for (pass = 1; pass <= 2; ++pass)
    {
        ptrdiff_t   thistimei,
                    thistimecnt,
                    thistimelim;
        int         thisleapi,
                    thisleapcnt,
                    thisleaplim;
        int         currenttype,
                    thisdefaulttype;
        bool        locut,
                    hicut;
        zic_t       lo;
        int         old0;
        char        omittype[TZ_MAX_TYPES];
        int         typemap[TZ_MAX_TYPES];
        int         thistypecnt,
                    stdcnt,
                    utcnt;
        char        thischars[TZ_MAX_CHARS];
        int         thischarcnt;
        bool        toomanytimes;
        int         indmap[TZ_MAX_CHARS];
 
        if (pass == 1)
        {
            /*
             * Arguably the default time type in the 32-bit data should be
             * range32.defaulttype, which is suited for timestamps just before
             * INT32_MIN.  However, zic traditionally used the time type of
             * the indefinite past instead.  Internet RFC 8532 says readers
             * should ignore 32-bit data, so this discrepancy matters only to
             * obsolete readers where the traditional type might be more
             * appropriate even if it's "wrong".  So, use the historical zic
             * value, unless -r specifies a low cutoff that excludes some
             * 32-bit timestamps.
             */
            thisdefaulttype = (lo_time <= INT32_MIN
                               ? range64.defaulttype
                               : range32.defaulttype);
 
            thistimei = range32.base;
            thistimecnt = range32.count;
            toomanytimes = thistimecnt >> 31 >> 1 != 0;
            thisleapi = range32.leapbase;
            thisleapcnt = range32.leapcount;
            locut = INT32_MIN < lo_time;
            hicut = hi_time < INT32_MAX;
        }
        else
        {
            thisdefaulttype = range64.defaulttype;
            thistimei = range64.base;
            thistimecnt = range64.count;
            toomanytimes = thistimecnt >> 31 >> 31 >> 2 != 0;
            thisleapi = range64.leapbase;
            thisleapcnt = range64.leapcount;
            locut = min_time < lo_time;
            hicut = hi_time < max_time;
        }
        if (toomanytimes)
            error(_("too many transition times"));
 
        /*
         * Keep the last too-low transition if no transition is exactly at LO.
         * The kept transition will be output as a LO "transition"; see
         * "Output a LO_TIME transition" below.  This is needed when the
         * output is truncated at the start, and is also useful when catering
         * to buggy 32-bit clients that do not use time type 0 for timestamps
         * before the first transition.
         */
        if (0 < thistimei && ats[thistimei] != lo_time)
        {
            thistimei--;
            thistimecnt++;
            locut = false;
        }
 
        thistimelim = thistimei + thistimecnt;
        thisleaplim = thisleapi + thisleapcnt;
        if (thistimecnt != 0)
        {
            if (ats[thistimei] == lo_time)
                locut = false;
            if (hi_time < ZIC_MAX && ats[thistimelim - 1] == hi_time + 1)
                hicut = false;
        }
        memset(omittype, true, typecnt);
        omittype[thisdefaulttype] = false;
        for (i = thistimei; i < thistimelim; i++)
            omittype[types[i]] = false;
 
        /*
         * Reorder types to make THISDEFAULTTYPE type 0. Use TYPEMAP to swap
         * OLD0 and THISDEFAULTTYPE so that THISDEFAULTTYPE appears as type 0
         * in the output instead of OLD0.  TYPEMAP also omits unused types.
         */
        old0 = strlen(omittype);
 
#ifndef LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH
 
        /*
         * For some pre-2011 systems: if the last-to-be-written standard (or
         * daylight) type has an offset different from the most recently used
         * offset, append an (unused) copy of the most recently used type (to
         * help get global "altzone" and "timezone" variables set correctly).
         */
        if (want_bloat())
        {
            int         mrudst,
                        mrustd,
                        hidst,
                        histd,
                        type;
 
            hidst = histd = mrudst = mrustd = -1;
            for (i = thistimei; i < thistimelim; ++i)
                if (isdsts[types[i]])
                    mrudst = types[i];
                else
                    mrustd = types[i];
            for (i = old0; i < typecnt; i++)
            {
                int         h = (i == old0 ? thisdefaulttype
                                 : i == thisdefaulttype ? old0 : i);
 
                if (!omittype[h])
                {
                    if (isdsts[h])
                        hidst = i;
                    else
                        histd = i;
                }
            }
            if (hidst >= 0 && mrudst >= 0 && hidst != mrudst &&
                utoffs[hidst] != utoffs[mrudst])
            {
                isdsts[mrudst] = -1;
                type = addtype(utoffs[mrudst],
                               &chars[desigidx[mrudst]],
                               true,
                               ttisstds[mrudst],
                               ttisuts[mrudst]);
                isdsts[mrudst] = 1;
                omittype[type] = false;
            }
            if (histd >= 0 && mrustd >= 0 && histd != mrustd &&
                utoffs[histd] != utoffs[mrustd])
            {
                isdsts[mrustd] = -1;
                type = addtype(utoffs[mrustd],
                               &chars[desigidx[mrustd]],
                               false,
                               ttisstds[mrustd],
                               ttisuts[mrustd]);
                isdsts[mrustd] = 0;
                omittype[type] = false;
            }
        }
#endif                          /* !defined
                                 * LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH */
        thistypecnt = 0;
        for (i = old0; i < typecnt; i++)
            if (!omittype[i])
                typemap[i == old0 ? thisdefaulttype
                        : i == thisdefaulttype ? old0 : i]
                    = thistypecnt++;
 
        for (i = 0; i < sizeof indmap / sizeof indmap[0]; ++i)
            indmap[i] = -1;
        thischarcnt = stdcnt = utcnt = 0;
        for (i = old0; i < typecnt; i++)
        {
            char       *thisabbr;
 
            if (omittype[i])
                continue;
            if (ttisstds[i])
                stdcnt = thistypecnt;
            if (ttisuts[i])
                utcnt = thistypecnt;
            if (indmap[desigidx[i]] >= 0)
                continue;
            thisabbr = &chars[desigidx[i]];
            for (j = 0; j < thischarcnt; ++j)
                if (strcmp(&thischars[j], thisabbr) == 0)
                    break;
            if (j == thischarcnt)
            {
                strcpy(&thischars[thischarcnt], thisabbr);
                thischarcnt += strlen(thisabbr) + 1;
            }
            indmap[desigidx[i]] = j;
        }
        if (pass == 1 && !want_bloat())
        {
            utcnt = stdcnt = thisleapcnt = 0;
            thistimecnt = -(locut + hicut);
            thistypecnt = thischarcnt = 1;
            thistimelim = thistimei;
        }
#define DO(field)   fwrite(tzh.field, sizeof tzh.field, 1, fp)
        tzh = tzh0;
        memcpy(tzh.tzh_magic, TZ_MAGIC, sizeof tzh.tzh_magic);
        tzh.tzh_version[0] = version;
        convert(utcnt, tzh.tzh_ttisutcnt);
        convert(stdcnt, tzh.tzh_ttisstdcnt);
        convert(thisleapcnt, tzh.tzh_leapcnt);
        convert(locut + thistimecnt + hicut, tzh.tzh_timecnt);
        convert(thistypecnt, tzh.tzh_typecnt);
        convert(thischarcnt, tzh.tzh_charcnt);
        DO(tzh_magic);
        DO(tzh_version);
        DO(tzh_reserved);
        DO(tzh_ttisutcnt);
        DO(tzh_ttisstdcnt);
        DO(tzh_leapcnt);
        DO(tzh_timecnt);
        DO(tzh_typecnt);
        DO(tzh_charcnt);
#undef DO
        if (pass == 1 && !want_bloat())
        {
            /* Output a minimal data block with just one time type.  */
            puttzcode(0, fp);   /* utoff */
            putc(0, fp);        /* dst */
            putc(0, fp);        /* index of abbreviation */
            putc(0, fp);        /* empty-string abbreviation */
            continue;
        }
 
        /* PG: print current timezone abbreviations if requested */
        if (print_abbrevs && pass == 2)
        {
            /* Print "type" data for periods ending after print_cutoff */
            for (i = thistimei; i < thistimelim; ++i)
            {
                if (i == thistimelim - 1 || ats[i + 1] > print_cutoff)
                {
                    unsigned char tm = types[i];
                    char       *thisabbrev = &thischars[indmap[desigidx[tm]]];
 
                    fprintf(stdout, "%s\t%" PRIdFAST64 "%s\n",
                            thisabbrev,
                            utoffs[tm],
                            isdsts[tm] ? "\tD" : "");
                }
            }
            /* Print the default type if we have no transitions at all */
            if (thistimei >= thistimelim)
            {
                unsigned char tm = defaulttype;
                char       *thisabbrev = &thischars[indmap[desigidx[tm]]];
 
                fprintf(stdout, "%s\t%" PRIdFAST64 "%s\n",
                        thisabbrev,
                        utoffs[tm],
                        isdsts[tm] ? "\tD" : "");
            }
        }
 
        /*
         * Output a LO_TIME transition if needed; see limitrange. But do not
         * go below the minimum representable value for this pass.
         */
        lo = pass == 1 && lo_time < INT32_MIN ? INT32_MIN : lo_time;
 
        if (locut)
            puttzcodepass(lo, fp, pass);
        for (i = thistimei; i < thistimelim; ++i)
        {
            zic_t       at = ats[i] < lo ? lo : ats[i];
 
            puttzcodepass(at, fp, pass);
        }
        if (hicut)
            puttzcodepass(hi_time + 1, fp, pass);
        currenttype = 0;
        if (locut)
            putc(currenttype, fp);
        for (i = thistimei; i < thistimelim; ++i)
        {
            currenttype = typemap[types[i]];
            putc(currenttype, fp);
        }
        if (hicut)
            putc(currenttype, fp);
 
        for (i = old0; i < typecnt; i++)
        {
            int         h = (i == old0 ? thisdefaulttype
                             : i == thisdefaulttype ? old0 : i);
 
            if (!omittype[h])
            {
                puttzcode(utoffs[h], fp);
                putc(isdsts[h], fp);
                putc(indmap[desigidx[h]], fp);
            }
        }
        if (thischarcnt != 0)
            fwrite(thischars, sizeof thischars[0],
                   thischarcnt, fp);
        for (i = thisleapi; i < thisleaplim; ++i)
        {
            zic_t       todo;
 
            if (roll[i])
            {
                if (timecnt == 0 || trans[i] < ats[0])
                {
                    j = 0;
                    while (isdsts[j])
                        if (++j >= typecnt)
                        {
                            j = 0;
                            break;
                        }
                }
                else
                {
                    j = 1;
                    while (j < timecnt &&
                           trans[i] >= ats[j])
                        ++j;
                    j = types[j - 1];
                }
                todo = tadd(trans[i], -utoffs[j]);
            }
            else
                todo = trans[i];
            puttzcodepass(todo, fp, pass);
            puttzcode(corr[i], fp);
        }
        if (stdcnt != 0)
            for (i = old0; i < typecnt; i++)
                if (!omittype[i])
                    putc(ttisstds[i], fp);
        if (utcnt != 0)
            for (i = old0; i < typecnt; i++)
                if (!omittype[i])
                    putc(ttisuts[i], fp);
    }
    fprintf(fp, "\n%s\n", string);
    close_file(fp, directory, name);
    free(ats);
}

References _, _Alignof, addtype(), align_to(), attype::at, atcomp(), attypes, chars, close_file(), convert(), corr, timerange::defaulttype, desigidx, directory, DO, emalloc(), error(), EXIT_FAILURE, fb(), fprintf, free, hi_time, i, isdsts, j, leapcnt, limitrange(), lo_time, max_time, memcpy(), min_time, mkdirs(), name, noise, print_abbrevs, print_cutoff, progname, puttzcode(), puttzcodepass(), qsort, roll, size_product(), strerror, tadd(), timecnt, tm, trans, ttisstds, ttisuts, type, attype::type, typecnt, types, TZ_MAGIC, TZ_MAX_CHARS, TZ_MAX_TIMES, TZ_MAX_TYPES, tzhead::tzh_charcnt, tzhead::tzh_leapcnt, tzhead::tzh_magic, tzhead::tzh_timecnt, tzhead::tzh_ttisstdcnt, tzhead::tzh_ttisutcnt, tzhead::tzh_typecnt, tzhead::tzh_version, utoffs, want_bloat(), warning(), WORK_AROUND_QTBUG_53071, and ZIC_MAX.

Referenced by outzone().

Variable Documentation

attypes

struct attype * attypes

static

Referenced by addtt(), outzone(), and writezone().

begin_years

struct lookup const begin_years[]

static

Initial value:

= {
    {"minimum", YR_MINIMUM},
    {"maximum", YR_MAXIMUM},
    {NULL, 0}
}

Definition at line 369 of file zic.c.

                                           {
    {"minimum", YR_MINIMUM},
    {"maximum", YR_MAXIMUM},
    {NULL, 0}
};

Referenced by rulesub().

bloat

int bloat

static

Definition at line 667 of file zic.c.

Referenced by main(), and want_bloat().

charcnt

int charcnt

static

Definition at line 182 of file zic.c.

Referenced by addtype(), newabbr(), outzone(), pg_interpret_timezone_abbrev(), pg_timezone_abbrev_is_known(), tzloadbody(), and tzparse().

chars

char chars[TZ_MAX_CHARS]

static

Definition at line 408 of file zic.c.

Referenced by addtype(), getColorInfo(), initPopulateTable(), newabbr(), pg_reg_getcharacters(), and writezone().

comment_leapexpires

zic_t comment_leapexpires = -1

static

Definition at line 619 of file zic.c.

Referenced by adjleap(), and infile().

corr

zic_t corr[TZ_MAX_LEAPS]

static

Definition at line 410 of file zic.c.

Referenced by adjleap(), import_pg_statistic(), leapadd(), timesub(), tzloadbody(), and writezone().

desigidx

unsigned char desigidx[TZ_MAX_TYPES]

static

Definition at line 405 of file zic.c.

Referenced by addtype(), init_ttinfo(), tzloadbody(), and writezone().

directory

const char* directory

static

Definition at line 658 of file zic.c.

Referenced by create_manifest_writer(), CreateBackupStreamer(), dolink(), GetConfFilesInDir(), identify_target_directory(), main(), open_file_in_directory(), PathNameCreateTemporaryDir(), relname(), search_directory(), verify_directory(), and writezone().

end_years

struct lookup const end_years[]

static

Initial value:

= {
    {"minimum", YR_MINIMUM},
    {"maximum", YR_MAXIMUM},
    {"only", YR_ONLY},
    {NULL, 0}
}

Definition at line 375 of file zic.c.

                                         {
    {"minimum", YR_MINIMUM},
    {"maximum", YR_MAXIMUM},
    {"only", YR_ONLY},
    {NULL, 0}
};

Referenced by rulesub().

errors

bool errors

static

Definition at line 183 of file zic.c.

Referenced by associate(), error(), and main().

filename

const char* filename

static

Definition at line 185 of file zic.c.

Referenced by eats(), infile(), inlink(), inrule(), inzsub(), and verror().

hi_time

zic_t hi_time = MAXVAL(zic_t, TIME_T_BITS_IN_FILE)

static

Definition at line 613 of file zic.c.

Referenced by adjleap(), stringzone(), timerange_option(), and writezone().

isdsts

char isdsts[TZ_MAX_TYPES]

static

Definition at line 404 of file zic.c.

Referenced by addtype(), and writezone().

lasts

struct lookup const lasts[]

static

Initial value:

= {
    {"last-Sunday", TM_SUNDAY},
    {"last-Monday", TM_MONDAY},
    {"last-Tuesday", TM_TUESDAY},
    {"last-Wednesday", TM_WEDNESDAY},
    {"last-Thursday", TM_THURSDAY},
    {"last-Friday", TM_FRIDAY},
    {"last-Saturday", TM_SATURDAY},
    {NULL, 0}
}

Definition at line 358 of file zic.c.

                                     {
    {"last-Sunday", TM_SUNDAY},
    {"last-Monday", TM_MONDAY},
    {"last-Tuesday", TM_TUESDAY},
    {"last-Wednesday", TM_WEDNESDAY},
    {"last-Thursday", TM_THURSDAY},
    {"last-Friday", TM_FRIDAY},
    {"last-Saturday", TM_SATURDAY},
    {NULL, 0}
};

Referenced by byword(), and rulesub().

lcltime

const char* lcltime

static

Definition at line 657 of file zic.c.

Referenced by inzone(), and main().

leap_line_codes

struct lookup const leap_line_codes[]

static

Initial value:

= {
    {"Leap", LC_LEAP},
    {"Expires", LC_EXPIRES},
    {NULL, 0}
}

Definition at line 325 of file zic.c.

                                               {
    {"Leap", LC_LEAP},
    {"Expires", LC_EXPIRES},
    {NULL, 0}
};

Referenced by infile().

leap_types

struct lookup const leap_types[]

static

Initial value:

= {
    {"Rolling", true},
    {"Stationary", false},
    {NULL, 0}
}

Definition at line 382 of file zic.c.

                                          {
    {"Rolling", true},
    {"Stationary", false},
    {NULL, 0}
};

Referenced by inleap().

leapcnt

int leapcnt

static

Definition at line 186 of file zic.c.

Referenced by adjleap(), leapadd(), tzloadbody(), and writezone().

leapexpires

zic_t leapexpires = -1

static

Definition at line 616 of file zic.c.

Referenced by adjleap(), and inexpires().

leapmaxyear

zic_t leapmaxyear

static

Definition at line 189 of file zic.c.

Referenced by getleapdatetime(), and outzone().

leapminyear

zic_t leapminyear

static

Definition at line 188 of file zic.c.

Referenced by getleapdatetime(), and outzone().

leapsec

const char* leapsec

static

Definition at line 659 of file zic.c.

Referenced by infile(), and main().

leapseen

bool leapseen

static

Definition at line 187 of file zic.c.

Referenced by getleapdatetime(), and outzone().

len_months

const int len_months[2][MONSPERYEAR]

static

Initial value:

= {
    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
    {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
}

Definition at line 388 of file zic.c.

                                              {
    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
    {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};

Referenced by getleapdatetime(), rpytime(), rulesub(), and stringrule().

len_years

const int len_years[2]

static

Initial value:

= {
    DAYSPERNYEAR, DAYSPERLYEAR
}

Definition at line 393 of file zic.c.

                                {
    DAYSPERNYEAR, DAYSPERLYEAR
};

Referenced by getleapdatetime(), and rpytime().

linenum

lineno_t linenum

static

Definition at line 190 of file zic.c.

Referenced by eats(), inlink(), inrule(), inzsub(), and verror().

links

struct link* links

static

Definition at line 306 of file zic.c.

Referenced by inlink(), and main().

lo_time

zic_t lo_time = MINVAL(zic_t, TIME_T_BITS_IN_FILE)

static

Definition at line 612 of file zic.c.

Referenced by timerange_option(), and writezone().

max_abbrvar_len

int max_abbrvar_len = PERCENT_Z_LEN_BOUND

static

Definition at line 191 of file zic.c.

Referenced by inrule(), and outzone().

max_format_len

int max_format_len

static

Definition at line 192 of file zic.c.

Referenced by inzsub(), and outzone().

max_time

zic_t const max_time = MAXVAL(zic_t, TIME_T_BITS_IN_FILE)

static

Definition at line 606 of file zic.c.

Referenced by getleapdatetime(), inzsub(), outzone(), rpytime(), stringzone(), tadd(), timerange_option(), and writezone().

max_year

zic_t max_year

static

Definition at line 193 of file zic.c.

Referenced by outzone(), and updateminmax().

min_time

zic_t const min_time = MINVAL(zic_t, TIME_T_BITS_IN_FILE)

static

Definition at line 605 of file zic.c.

Referenced by getleapdatetime(), inzsub(), outzone(), rpytime(), tadd(), timerange_option(), and writezone().

min_year

zic_t min_year

static

Definition at line 194 of file zic.c.

Referenced by outzone(), and updateminmax().

mon_names

struct lookup const mon_names[]

static

Initial value:

= {
    {"January", TM_JANUARY},
    {"February", TM_FEBRUARY},
    {"March", TM_MARCH},
    {"April", TM_APRIL},
    {"May", TM_MAY},
    {"June", TM_JUNE},
    {"July", TM_JULY},
    {"August", TM_AUGUST},
    {"September", TM_SEPTEMBER},
    {"October", TM_OCTOBER},
    {"November", TM_NOVEMBER},
    {"December", TM_DECEMBER},
    {NULL, 0}
}

Definition at line 331 of file zic.c.

                                         {
    {"January", TM_JANUARY},
    {"February", TM_FEBRUARY},
    {"March", TM_MARCH},
    {"April", TM_APRIL},
    {"May", TM_MAY},
    {"June", TM_JUNE},
    {"July", TM_JULY},
    {"August", TM_AUGUST},
    {"September", TM_SEPTEMBER},
    {"October", TM_OCTOBER},
    {"November", TM_NOVEMBER},
    {"December", TM_DECEMBER},
    {NULL, 0}
};

Referenced by getleapdatetime(), and rulesub().

nlinks

ptrdiff_t nlinks

static

Definition at line 307 of file zic.c.

Referenced by inlink(), and main().

nlinks_alloc

ptrdiff_t nlinks_alloc

static

Definition at line 308 of file zic.c.

Referenced by inlink().

noise

bool noise

static

Definition at line 195 of file zic.c.

Referenced by byword(), componentcheck(), gethms(), inzsub(), main(), namecheck(), newabbr(), outzone(), rpytime(), and writezone().

nrules

ptrdiff_t nrules

static

Definition at line 291 of file zic.c.

Referenced by associate(), and inrule().

nrules_alloc

ptrdiff_t nrules_alloc

static

Definition at line 292 of file zic.c.

Referenced by inrule().

nzones

ptrdiff_t nzones

static

Definition at line 295 of file zic.c.

Referenced by associate(), inzone(), inzsub(), and main().

nzones_alloc

ptrdiff_t nzones_alloc

static

Definition at line 296 of file zic.c.

Referenced by inzsub().

print_abbrevs

bool print_abbrevs

static

Definition at line 196 of file zic.c.

Referenced by main(), and writezone().

print_cutoff

zic_t print_cutoff

static

Definition at line 197 of file zic.c.

Referenced by main(), and writezone().

progname

const char* progname

static

Definition at line 200 of file zic.c.

Referenced by change_directory(), close_file(), dolink(), infile(), main(), memory_exhausted(), mkdirs(), rulesub(), usage(), and writezone().

psxrules

const char* psxrules

static

Definition at line 656 of file zic.c.

Referenced by inzone(), and main().

PTRDIFF_MAX

ptrdiff_t const PTRDIFF_MAX = MAXVAL(ptrdiff_t, TYPE_BIT(ptrdiff_t))

static

Definition at line 49 of file zic.c.

Referenced by growalloc().

rfilename

const char* rfilename

static

Definition at line 198 of file zic.c.

Referenced by eats(), and verror().

rlinenum

lineno_t rlinenum

static

Definition at line 199 of file zic.c.

Referenced by eats(), and verror().

roll

char roll[TZ_MAX_LEAPS]

static

Definition at line 411 of file zic.c.

Referenced by leapadd(), and writezone().

rules

struct rule* rules

static

Definition at line 290 of file zic.c.

Referenced by associate(), fireRIRrules(), inrule(), and RelationBuildRuleLock().

timecnt

ptrdiff_t timecnt

static

Definition at line 201 of file zic.c.

Referenced by addtt(), outzone(), tzloadbody(), tzparse(), and writezone().

timecnt_alloc

ptrdiff_t timecnt_alloc

static

Definition at line 202 of file zic.c.

Referenced by addtt().

trans

zic_t trans[TZ_MAX_LEAPS]

static

Definition at line 409 of file zic.c.

Referenced by add_tabstat_xact_level(), adjleap(), AtEOSubXact_PgStat_Relations(), AtEOXact_PgStat_Relations(), AtPrepare_PgStat_Relations(), find_tabstat_entry(), leapadd(), limitrange(), pgstat_report_analyze(), PostPrepare_PgStat_Relations(), restore_truncdrop_counters(), save_truncdrop_counters(), sqlnotice(), and writezone().

ttisstds

bool ttisstds[TZ_MAX_TYPES]

static

Definition at line 406 of file zic.c.

Referenced by addtype(), and writezone().

ttisuts

bool ttisuts[TZ_MAX_TYPES]

static

Definition at line 407 of file zic.c.

Referenced by addtype(), and writezone().

typecnt

int typecnt

static

Definition at line 203 of file zic.c.

Referenced by addtype(), outzone(), tzloadbody(), and writezone().

tzdefault

const char* tzdefault

static

Definition at line 660 of file zic.c.

Referenced by inzone(), and main().

utoffs

zic_t utoffs[TZ_MAX_TYPES]

static

Definition at line 403 of file zic.c.

Referenced by addtype(), and writezone().

warnings

bool warnings

static

Definition at line 184 of file zic.c.

Referenced by main(), and warning().

wday_names

struct lookup const wday_names[]

static

Initial value:

= {
    {"Sunday", TM_SUNDAY},
    {"Monday", TM_MONDAY},
    {"Tuesday", TM_TUESDAY},
    {"Wednesday", TM_WEDNESDAY},
    {"Thursday", TM_THURSDAY},
    {"Friday", TM_FRIDAY},
    {"Saturday", TM_SATURDAY},
    {NULL, 0}
}

Definition at line 347 of file zic.c.

                                          {
    {"Sunday", TM_SUNDAY},
    {"Monday", TM_MONDAY},
    {"Tuesday", TM_TUESDAY},
    {"Wednesday", TM_WEDNESDAY},
    {"Thursday", TM_THURSDAY},
    {"Friday", TM_FRIDAY},
    {"Saturday", TM_SATURDAY},
    {NULL, 0}
};

Referenced by byword(), and rulesub().

zi_line_codes

struct lookup const zi_line_codes[]

static

Initial value:

= {
    {"Rule", LC_RULE},
    {"Zone", LC_ZONE},
    {"Link", LC_LINK},
    {NULL, 0}
}

Definition at line 319 of file zic.c.

                                             {
    {"Rule", LC_RULE},
    {"Zone", LC_ZONE},
    {"Link", LC_LINK},
    {NULL, 0}
};

Referenced by infile().

zones

struct zone* zones

static

Definition at line 294 of file zic.c.

Referenced by associate(), inzone(), inzsub(), and main().