#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 PG_INT64_MIN

#define	ZIC_MAX PG_INT64_MAX

#define	ZIC_MAX_ABBR_LEN_WO_WARN 6

#define	MKDIR_UMASK 0755

#define	linkat(fromdir, from, todir, to, flag) (itssymlink(from) ? (errno = ENOTSUP, -1) : link(from, to))

#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	LC_RULE 0

#define	LC_ZONE 1

#define	LC_LINK 2

#define	LC_LEAP 3

#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_FROM 1

#define	LF_TO 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	YR_MINIMUM 0

#define	YR_MAXIMUM 1

#define	YR_ONLY 2

#define	TIME_T_BITS_IN_FILE 64

#define	ZIC_BLOAT_DEFAULT "fat"

#define	DO(field) fwrite(tzh.field, sizeof tzh.field, 1, fp)

#define	LDAYSPERWEEK ((zic_t) DAYSPERWEEK)

Typedefs
typedef int64	zic_t

typedef int	lineno_t

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

enum	{ WORK_AROUND_QTBUG_53071 = true }

Functions
int	link (const char fromname, const char toname)

static void	memory_exhausted (const char *msg) pg_attribute_noreturn()

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

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

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

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

static void	addtt (zic_t starttime, int type)

static int	addtype (zic_t, char const *, bool, bool, bool)

static void	leapadd (zic_t, bool, int, int)

static void	adjleap (void)

static void	associate (void)

static void	dolink (const char , const char , bool)

static char **	getfields (char *buf)

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

static zic_t	getsave (char , bool )

static void	infile (const char *filename)

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

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

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

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

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

static bool	inzsub (char **, int, bool)

static bool	itsdir (char const *)

static bool	itssymlink (char const *)

static bool	is_alpha (char a)

static char	lowerit (char)

static void	mkdirs (char const *, bool)

static void	newabbr (const char *abbr)

static zic_t	oadd (zic_t t1, zic_t t2)

static void	outzone (const struct zone *zp, ptrdiff_t ntzones)

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

static void	rulesub (struct rule rp, const char loyearp, const char hiyearp, const char typep, const char monthp, const char dayp, const char *timep)

static zic_t	tadd (zic_t t1, zic_t t2)

static bool	yearistype (zic_t year, const char *type)

static struct lookup const *	byword (const char string, const struct lookup lp)

static size_t	size_product (size_t nitems, size_t itemsize)

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 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 int	hardlinkerr (char const from, char const to)

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

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

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

static void	puttzcode (const int32 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 char *	shellquote (char b, char const s)

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 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 const char *	psxrules

static const char *	lcltime

static const char *	directory

static const char *	leapsec

static const char *	tzdefault

static const char *	yitcommand

static int	bloat

Macro Definition Documentation

◆ DC_DOM

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

Definition at line 94 of file zic.c.

Referenced by outzone(), rulesub(), stringrule(), and stringzone().

◆ DC_DOWGEQ

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

Definition at line 95 of file zic.c.

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

◆ DC_DOWLEQ

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

Definition at line 96 of file zic.c.

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

◆ DO

#define DO ( field ) fwrite(tzh.field, sizeof tzh.field, 1, fp)

Referenced by writezone().

◆ LC_LEAP

#define LC_LEAP 3

Definition at line 204 of file zic.c.

Referenced by infile().

◆ LC_LINK

#define LC_LINK 2

Definition at line 203 of file zic.c.

Referenced by infile().

◆ LC_RULE

#define LC_RULE 0

Definition at line 201 of file zic.c.

Referenced by infile().

◆ LC_ZONE

#define LC_ZONE 1

Definition at line 202 of file zic.c.

Referenced by infile().

◆ LDAYSPERWEEK

#define LDAYSPERWEEK ((zic_t) DAYSPERWEEK)

Referenced by rpytime().

◆ LEAP_FIELDS

#define LEAP_FIELDS 7

Definition at line 268 of file zic.c.

Referenced by inleap().

◆ LF_FROM

#define LF_FROM 1

Definition at line 254 of file zic.c.

Referenced by inlink().

◆ LF_TO

#define LF_TO 2

Definition at line 255 of file zic.c.

Referenced by inlink().

◆ LINK_FIELDS

#define LINK_FIELDS 3

Definition at line 256 of file zic.c.

Referenced by inlink().

◆ linkat

#define linkat	(	fromdir,
		from,
		todir,
		to,
		flag
	)	(itssymlink(from) ? (errno = ENOTSUP, -1) : link(from, to))

Definition at line 41 of file zic.c.

Referenced by hardlinkerr().

◆ LP_CORR

#define LP_CORR 5

Definition at line 266 of file zic.c.

Referenced by inleap().

◆ LP_DAY

#define LP_DAY 3

Definition at line 264 of file zic.c.

Referenced by inleap().

◆ LP_MONTH

#define LP_MONTH 2

Definition at line 263 of file zic.c.

Referenced by inleap().

◆ LP_ROLL

#define LP_ROLL 6

Definition at line 267 of file zic.c.

Referenced by inleap().

◆ LP_TIME

#define LP_TIME 4

Definition at line 265 of file zic.c.

Referenced by inleap().

◆ LP_YEAR

#define LP_YEAR 1

Definition at line 262 of file zic.c.

Referenced by inleap().

◆ MKDIR_UMASK

#define MKDIR_UMASK 0755

Definition at line 37 of file zic.c.

Referenced by mkdirs().

◆ RF_ABBRVAR

#define RF_ABBRVAR 9

Definition at line 247 of file zic.c.

Referenced by inrule().

◆ RF_COMMAND

#define RF_COMMAND 4

Definition at line 242 of file zic.c.

Referenced by inrule().

◆ RF_DAY

#define RF_DAY 6

Definition at line 244 of file zic.c.

Referenced by inrule().

◆ RF_HIYEAR

#define RF_HIYEAR 3

Definition at line 241 of file zic.c.

Referenced by inrule().

◆ RF_LOYEAR

#define RF_LOYEAR 2

Definition at line 240 of file zic.c.

Referenced by inrule().

◆ RF_MONTH

#define RF_MONTH 5

Definition at line 243 of file zic.c.

Referenced by inrule().

◆ RF_NAME

#define RF_NAME 1

Definition at line 239 of file zic.c.

Referenced by inrule().

◆ RF_SAVE

#define RF_SAVE 8

Definition at line 246 of file zic.c.

Referenced by inrule().

◆ RF_TOD

#define RF_TOD 7

Definition at line 245 of file zic.c.

Referenced by inrule().

◆ RULE_FIELDS

#define RULE_FIELDS 10

Definition at line 248 of file zic.c.

Referenced by inrule().

◆ TIME_T_BITS_IN_FILE

#define TIME_T_BITS_IN_FILE 64

Definition at line 576 of file zic.c.

◆ YR_MAXIMUM

#define YR_MAXIMUM 1

Definition at line 275 of file zic.c.

Referenced by rulesub().

◆ YR_MINIMUM

#define YR_MINIMUM 0

Definition at line 274 of file zic.c.

Referenced by rulesub().

◆ YR_ONLY

#define YR_ONLY 2

Definition at line 276 of file zic.c.

Referenced by rulesub().

◆ ZF_FORMAT

#define ZF_FORMAT 4

Definition at line 213 of file zic.c.

Referenced by inzsub().

◆ ZF_NAME

#define ZF_NAME 1

Definition at line 210 of file zic.c.

Referenced by inzone(), and inzsub().

◆ ZF_RULE

#define ZF_RULE 3

Definition at line 212 of file zic.c.

Referenced by inzsub().

◆ ZF_STDOFF

#define ZF_STDOFF 2

Definition at line 211 of file zic.c.

Referenced by inzsub().

◆ ZF_TILDAY

#define ZF_TILDAY 7

Definition at line 216 of file zic.c.

Referenced by inzsub().

◆ ZF_TILMONTH

#define ZF_TILMONTH 6

Definition at line 215 of file zic.c.

Referenced by inzsub().

◆ ZF_TILTIME

#define ZF_TILTIME 8

Definition at line 217 of file zic.c.

Referenced by inzsub().

◆ ZF_TILYEAR

#define ZF_TILYEAR 5

Definition at line 214 of file zic.c.

Referenced by inzsub().

◆ ZFC_FORMAT

#define ZFC_FORMAT 2

Definition at line 227 of file zic.c.

Referenced by inzsub().

◆ ZFC_RULE

#define ZFC_RULE 1

Definition at line 226 of file zic.c.

Referenced by inzsub().

◆ ZFC_STDOFF

#define ZFC_STDOFF 0

Definition at line 225 of file zic.c.

Referenced by inzsub().

◆ ZFC_TILDAY

#define ZFC_TILDAY 5

Definition at line 230 of file zic.c.

Referenced by inzsub().

◆ ZFC_TILMONTH

#define ZFC_TILMONTH 4

Definition at line 229 of file zic.c.

Referenced by inzsub().

◆ ZFC_TILTIME

#define ZFC_TILTIME 6

Definition at line 231 of file zic.c.

Referenced by inzsub().

◆ ZFC_TILYEAR

#define ZFC_TILYEAR 3

Definition at line 228 of file zic.c.

Referenced by inzsub().

◆ ZIC_BLOAT_DEFAULT

#define ZIC_BLOAT_DEFAULT "fat"

Definition at line 639 of file zic.c.

Referenced by main().

◆ ZIC_MAX

#define ZIC_MAX PG_INT64_MAX

Definition at line 27 of file zic.c.

Referenced by gethms(), limitrange(), oadd(), outzone(), rpytime(), rulesub(), stringzone(), and writezone().

◆ ZIC_MAX_ABBR_LEN_WO_WARN

#define ZIC_MAX_ABBR_LEN_WO_WARN 6

Definition at line 30 of file zic.c.

Referenced by newabbr().

◆ ZIC_MIN

#define ZIC_MIN PG_INT64_MIN

Definition at line 26 of file zic.c.

Referenced by oadd(), outzone(), rpytime(), and rulesub().

◆ ZIC_VERSION

#define ZIC_VERSION '3'

Definition at line 23 of file zic.c.

Referenced by outzone().

◆ ZIC_VERSION_PRE_2013

#define ZIC_VERSION_PRE_2013 '2'

Definition at line 22 of file zic.c.

Referenced by outzone().

◆ ZONE_MAXFIELDS

#define ZONE_MAXFIELDS 9

Definition at line 219 of file zic.c.

Referenced by inzone().

◆ ZONE_MINFIELDS

#define ZONE_MINFIELDS 5

Definition at line 218 of file zic.c.

◆ ZONEC_MAXFIELDS

#define ZONEC_MAXFIELDS 7

Definition at line 233 of file zic.c.

Referenced by inzcont().

◆ ZONEC_MINFIELDS

#define ZONEC_MINFIELDS 3

Definition at line 232 of file zic.c.

Typedef Documentation

◆ lineno_t

typedef int lineno_t

Definition at line 59 of file zic.c.

◆ zic_t

typedef int64 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 159 of file zic.c.

160 {

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

PERCENT_Z_LEN_BOUND

Definition: zic.c:161

◆ anonymous enum

anonymous enum

Enumerator
WORK_AROUND_QTBUG_53071

Definition at line 169 of file zic.c.

170 {

171 WORK_AROUND_QTBUG_53071 = true};

WORK_AROUND_QTBUG_53071

Definition: zic.c:171

Function Documentation

◆ abbroffset()

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

static

Definition at line 2553 of file zic.c.

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

Referenced by doabbr().

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

◆ addtt()

static void addtt	(	zic_t	starttime,
		int	type
	)

static

Definition at line 3317 of file zic.c.

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

Referenced by outzone().

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

◆ addtype()

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

static

Definition at line 3327 of file zic.c.

References _, charcnt, error(), EXIT_FAILURE, i, newabbr(), typecnt, TZ_MAX_TYPES, and want_bloat().

Referenced by outzone(), and writezone().

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

◆ adjleap()

static void adjleap ( void )

static

Definition at line 3401 of file zic.c.

References _, error(), EXIT_FAILURE, i, leapcnt, SECSPERDAY, and tadd().

Referenced by main().

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

◆ associate()

static void associate ( void )

static

Definition at line 1148 of file zic.c.

References _, eat(), error(), EXIT_FAILURE, getsave(), i, nrules, nzones, qsort, rule::r_filename, rule::r_linenum, rule::r_name, rcomp(), warning(), zone::z_filename, zone::z_format_specifier, zone::z_isdst, zone::z_linenum, zone::z_nrules, zone::z_rule, zone::z_rules, and zone::z_save.

Referenced by main().

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

◆ atcomp()

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

static

Definition at line 2004 of file zic.c.

Referenced by writezone().

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

◆ byword()

static const struct lookup * byword	(	const char *	string,
		const struct lookup *	lp
	)

static

Definition at line 3656 of file zic.c.

References _, ciequal(), ciprefix(), itsabbr(), lookup::l_word, warning(), and wday_names.

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

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

◆ change_directory()

static void change_directory ( char const * dir )

static

Definition at line 556 of file zic.c.

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

Referenced by main().

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

◆ ciequal()

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

static

Definition at line 3619 of file zic.c.

References lowerit().

Referenced by byword().

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

◆ ciprefix()

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

static

Definition at line 3645 of file zic.c.

References lowerit().

Referenced by byword().

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

◆ close_file()

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

static

Definition at line 521 of file zic.c.

References _, EXIT_FAILURE, fprintf, and strerror.

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

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

◆ componentcheck()

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

static

Definition at line 852 of file zic.c.

References _, error(), and warning().

Referenced by namecheck().

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

◆ convert()

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

static

Definition at line 1959 of file zic.c.

References i.

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

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

◆ convert64()

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

static

Definition at line 1970 of file zic.c.

References i.

Referenced by puttzcodepass().

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

◆ 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 2597 of file zic.c.

References abbroffset(), format, is_alpha(), PERCENT_Z_LEN_BOUND, sprintf, zone::z_format, zone::z_format_specifier, and zone::z_stdoff.

Referenced by outzone(), and stringzone().

 {
     char       *cp;
     char       *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;
 }

◆ dolink()

static void dolink	(	const char *	fromfield,
		const char *	tofield,
		bool	staysymlink
	)

static

Definition at line 997 of file zic.c.

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

Referenced by main().

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

◆ eat()

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

static

Definition at line 476 of file zic.c.

References eats().

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

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

◆ eats()

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

static

Definition at line 467 of file zic.c.

References name.

Referenced by eat(), and outzone().

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

◆ ecpyalloc()

static char* ecpyalloc ( char const * str )

static

Definition at line 440 of file zic.c.

References memcheck().

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

 {
     return memcheck(strdup(str));
 }

◆ emalloc()

static void* emalloc ( size_t size )

static

Definition at line 428 of file zic.c.

References malloc, and memcheck().

Referenced by getfields(), itsdir(), namecheck(), outzone(), writezone(), and yearistype().

 {
     return memcheck(malloc(size));
 }

◆ erealloc()

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

static

Definition at line 434 of file zic.c.

References memcheck(), and realloc.

Referenced by growalloc().

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

◆ error()

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

static

Definition at line 498 of file zic.c.

References generate_unaccent_rules::args, and verror().

Referenced by abbroffset(), addtype(), adjleap(), associate(), componentcheck(), getfields(), gethms(), infile(), inleap(), inlink(), inrule(), inzcont(), inzone(), inzsub(), leapadd(), main(), mkdirs(), newabbr(), outzone(), rpytime(), rulesub(), time_overflow(), writezone(), and yearistype().

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

◆ getfields()

static char ** getfields ( char * buf )

static

Definition at line 3722 of file zic.c.

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

Referenced by infile().

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

◆ gethms()

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

static

Definition at line 1337 of file zic.c.

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

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

 {
     /* PG: make hh be int not zic_t to avoid sscanf portability issues */
     int         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,
                    "%d%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';
             /* fallthrough */
         case 7:
             ok &= ssx == '.';
             if (ok && noise)
                 warning(_("fractional seconds rejected by"
                           " pre-2018 versions of zic"));
             /* fallthrough */
         case 5:
             ok &= mmx == ':';
             /* fallthrough */
         case 3:
             ok &= hhx == ':';
             /* 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;
     }
     /* Some compilers warn that this test is unsatisfiable for 32-bit ints */
 #if INT_MAX > PG_INT32_MAX
     if (ZIC_MAX / SECSPERHOUR < hh)
     {
         error(_("time overflow"));
         return 0;
     }
 #endif
     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 * (zic_t) hh * SECSPERHOUR,
                 sign * (mm * SECSPERMIN + ss));
 }

◆ getsave()

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

static

Definition at line 1415 of file zic.c.

References _, and gethms().

Referenced by associate(), and inrule().

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

◆ growalloc()

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

static

Definition at line 446 of file zic.c.

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

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

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

◆ hardlinkerr()

static int hardlinkerr	(	char const *	from,
		char const *	to
	)

static

Definition at line 989 of file zic.c.

References linkat.

Referenced by dolink().

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

◆ infile()

static void infile ( const char * filename )

static

Definition at line 1233 of file zic.c.

References _, buf, byword(), close_file(), eat(), error(), EXIT_FAILURE, fprintf, free, getfields(), inleap(), inlink(), inrule(), inzcont(), inzone(), lookup::l_value, LC_LEAP, LC_LINK, LC_RULE, LC_ZONE, leap_line_codes, strerror, and zi_line_codes.

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

 {
     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)
         {
             /* nothing to do */
         }
         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;
                     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"));
 }

◆ inleap()

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

static

Definition at line 1638 of file zic.c.

References _, byword(), EPOCH_YEAR, error(), gethms(), i, isleap, lookup::l_value, LEAP_FIELDS, leapadd(), LP_CORR, LP_DAY, LP_MONTH, LP_ROLL, LP_TIME, LP_YEAR, oadd(), SECSPERDAY, tadd(), and TM_JANUARY.

Referenced by infile().

 {
     const char *cp;
     const struct lookup *lp;
     zic_t       i,
                 j;
 
     /* PG: make year be int not zic_t to avoid sscanf portability issues */
     int         year;
     int         month,
                 day;
     zic_t       dayoff,
                 tod;
     zic_t       t;
     char        xs;
 
     if (nfields != LEAP_FIELDS)
     {
         error(_("wrong number of fields on Leap line"));
         return;
     }
     dayoff = 0;
     cp = fields[LP_YEAR];
     if (sscanf(cp, "%d%c", &year, &xs) != 1)
     {
         /*
          * Leapin' Lizards!
          */
         error(_("invalid leaping year"));
         return;
     }
     if (!leapseen || leapmaxyear < year)
         leapmaxyear = year;
     if (!leapseen || leapminyear > year)
         leapminyear = year;
     leapseen = true;
     j = EPOCH_YEAR;
     while (j != year)
     {
         if (year > j)
         {
             i = len_years[isleap(j)];
             ++j;
         }
         else
         {
             --j;
             i = -len_years[isleap(j)];
         }
         dayoff = oadd(dayoff, i);
     }
     if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL)
     {
         error(_("invalid month name"));
         return;
     }
     month = lp->l_value;
     j = TM_JANUARY;
     while (j != month)
     {
         i = len_months[isleap(year)][j];
         dayoff = oadd(dayoff, i);
         ++j;
     }
     cp = fields[LP_DAY];
     if (sscanf(cp, "%d%c", &day, &xs) != 1 ||
         day <= 0 || day > len_months[isleap(year)][month])
     {
         error(_("invalid day of month"));
         return;
     }
     dayoff = oadd(dayoff, day - 1);
     if (dayoff < min_time / SECSPERDAY)
     {
         error(_("time too small"));
         return;
     }
     if (dayoff > max_time / SECSPERDAY)
     {
         error(_("time too large"));
         return;
     }
     t = dayoff * SECSPERDAY;
     tod = gethms(fields[LP_TIME], _("invalid time of day"));
     cp = fields[LP_CORR];
     {
         bool        positive;
         int         count;
 
         if (strcmp(cp, "") == 0)
         {                       /* infile() turns "-" into "" */
             positive = false;
             count = 1;
         }
         else if (strcmp(cp, "+") == 0)
         {
             positive = true;
             count = 1;
         }
         else
         {
             error(_("illegal CORRECTION field on Leap line"));
             return;
         }
         if ((lp = byword(fields[LP_ROLL], leap_types)) == NULL)
         {
             error(_("illegal Rolling/Stationary field on Leap line"));
             return;
         }
         t = tadd(t, tod);
         if (t < 0)
         {
             error(_("leap second precedes Epoch"));
             return;
         }
         leapadd(t, positive, lp->l_value, count);
     }
 }

◆ inlink()

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

static

Definition at line 1758 of file zic.c.

References _, ecpyalloc(), error(), filename, growalloc(), link::l_filename, link::l_from, link::l_linenum, link::l_to, LF_FROM, LF_TO, linenum, LINK_FIELDS, and namecheck().

Referenced by infile().

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

◆ inrule()

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

static

Definition at line 1443 of file zic.c.

References _, ecpyalloc(), error(), filename, getsave(), growalloc(), linenum, 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, and rulesub().

Referenced by infile().

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

◆ inzcont()

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

static

Definition at line 1528 of file zic.c.

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

Referenced by infile().

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

◆ inzone()

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

static

Definition at line 1490 of file zic.c.

References _, error(), i, inzsub(), nzones, TZDEFRULES, ZF_NAME, and ZONE_MAXFIELDS.

Referenced by infile().

 {
     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 %d)"),
                   fields[ZF_NAME],
                   zones[i].z_filename,
                   zones[i].z_linenum);
             return false;
         }
     return inzsub(fields, nfields, false);
 }

◆ inzsub()

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

static

Definition at line 1539 of file zic.c.

References _, ecpyalloc(), error(), filename, gethms(), growalloc(), linenum, namecheck(), 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, and ZFC_TILYEAR.

Referenced by inzcont(), and inzone().

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

◆ is_alpha()

static bool is_alpha ( char a )

static

Definition at line 3491 of file zic.c.

Referenced by doabbr(), and newabbr().

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

◆ is_space()

static bool is_space ( char a )

static

Definition at line 3473 of file zic.c.

Referenced by getfields().

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

◆ itsabbr()

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

static

Definition at line 3628 of file zic.c.

References lowerit(), and word().

Referenced by byword().

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

◆ itsdir()

static bool itsdir ( char const * name )

static

Definition at line 1096 of file zic.c.

References emalloc(), EOVERFLOW, free, S_ISDIR, and stat.

Referenced by dolink(), and mkdirs().

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

◆ itssymlink()

static bool itssymlink ( char const * name )

static

Definition at line 1121 of file zic.c.

References readlink.

Referenced by dolink().

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

◆ leapadd()

static void leapadd	(	zic_t	t,
		bool	positive,
		int	rolling,
		int	count
	)

static

Definition at line 3372 of file zic.c.

References _, error(), EXIT_FAILURE, i, leapcnt, and TZ_MAX_LEAPS.

Referenced by inleap().

 {
     int         i,
                 j;
 
     if (leapcnt + (positive ? count : 1) > TZ_MAX_LEAPS)
     {
         error(_("too many leap seconds"));
         exit(EXIT_FAILURE);
     }
     for (i = 0; i < leapcnt; ++i)
         if (t <= trans[i])
             break;
     do
     {
         for (j = leapcnt; j > i; --j)
         {
             trans[j] = trans[j - 1];
             corr[j] = corr[j - 1];
             roll[j] = roll[j - 1];
         }
         trans[i] = t;
         corr[i] = positive ? 1 : -count;
         roll[i] = rolling;
         ++leapcnt;
     } while (positive && --count != 0);
 }

◆ 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 2022 of file zic.c.

References timerange::defaulttype, types, and ZIC_MAX.

Referenced by writezone().

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

◆ link()

int link	(	const char *	fromname,
		const char *	toname
	)

Referenced by mkdirs().

◆ lowerit()

static char lowerit ( char a )

static

Definition at line 3556 of file zic.c.

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

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

◆ main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 643 of file zic.c.

References _, adjleap(), associate(), change_directory(), close_file(), dolink(), eat(), error(), EXIT_FAILURE, EXIT_SUCCESS, fprintf, getopt(), i, infile(), nlinks, nzones, optarg, optind, outzone(), printf, S_IWGRP, S_IWOTH, generate_unaccent_rules::stdout, timerange_option(), TYPE_BIT, TZDEFAULT, TZDEFRULES, usage(), warning(), zone::z_name, and ZIC_BLOAT_DEFAULT.

 {
     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':
                 if (yitcommand == NULL)
                 {
                     warning(_("-y is obsolescent"));
                     yitcommand = strdup(optarg);
                 }
                 else
                 {
                     fprintf(stderr,
                             _("%s: More than one -y option specified\n"),
                             progname);
                     return EXIT_FAILURE;
                 }
                 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)
         bloat = strcmp(ZIC_BLOAT_DEFAULT, "slim") == 0 ? -1 : 1;
     if (directory == NULL)
         directory = "data";
     if (tzdefault == NULL)
         tzdefault = TZDEFAULT;
     if (yitcommand == NULL)
         yitcommand = "yearistype";
 
     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_from, links[i].l_to, false);
         if (noise)
             for (j = 0; j < nlinks; ++j)
                 if (strcmp(links[i].l_to,
                            links[j].l_from) == 0)
                     warning(_("link to link"));
     }
     if (lcltime != NULL)
     {
         eat(_("command line"), 1);
         dolink(lcltime, tzdefault, true);
     }
     if (psxrules != NULL)
     {
         eat(_("command line"), 1);
         dolink(psxrules, TZDEFRULES, true);
     }
     if (warnings && (ferror(stderr) || fclose(stderr) != 0))
         return EXIT_FAILURE;
     return errors ? EXIT_FAILURE : EXIT_SUCCESS;
 }

◆ memcheck()

static void* memcheck ( void * ptr )

static

Definition at line 420 of file zic.c.

References memory_exhausted(), and strerror.

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

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

◆ memory_exhausted()

static void memory_exhausted ( const char * msg )

static

Definition at line 405 of file zic.c.

References _, EXIT_FAILURE, and fprintf.

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

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

◆ mkdirs()

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

static

Definition at line 3953 of file zic.c.

References _, _dosmaperr(), ecpyalloc(), error(), EXIT_FAILURE, free, itsdir(), link(), mkdir, MKDIR_UMASK, name, and strerror.

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

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

◆ namecheck()

static bool namecheck ( const char * name )

static

Definition at line 896 of file zic.c.

References _, componentcheck(), emalloc(), i, name, relname, and warning().

Referenced by inlink(), and inzsub().

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

◆ newabbr()

static void newabbr ( const char * abbr )

static

Definition at line 3915 of file zic.c.

References _, error(), EXIT_FAILURE, GRANDPARENTED, i, is_alpha(), TZ_MAX_CHARS, warning(), and ZIC_MAX_ABBR_LEN_WO_WARN.

Referenced by addtype().

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

◆ oadd()

static zic_t oadd	(	zic_t	t1,
		zic_t	t2
	)

static

Definition at line 3769 of file zic.c.

References time_overflow(), ZIC_MAX, and ZIC_MIN.

Referenced by gethms(), inleap(), outzone(), and rpytime().

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

◆ outzone()

static void outzone	(	const struct zone *	zp,
		ptrdiff_t	ntzones
	)

static

Definition at line 2915 of file zic.c.

References _, addtt(), addtype(), attype::at, attypes, compat, DC_DOM, doabbr(), attype::dontmerge, eat(), eats(), emalloc(), EPOCH_YEAR, error(), free, i, INITIALIZE, max_abbrvar_len, max_year, oadd(), rule::r_abbrvar, rule::r_dayofmonth, rule::r_dycode, rule::r_filename, rule::r_hiwasnum, rule::r_hiyear, rule::r_isdst, rule::r_linenum, rule::r_lowasnum, rule::r_loyear, rule::r_month, rule::r_save, rule::r_temp, rule::r_tod, rule::r_todisstd, rule::r_todisut, rule::r_todo, rule::r_yrtype, rpytime(), stringzone(), tadd(), timecnt, TM_JANUARY, generate_unaccent_rules::type, attype::type, updateminmax(), want_bloat(), warning(), writezone(), yearistype(), YEARSPERREPEAT, zone::z_filename, zone::z_format, zone::z_isdst, zone::z_linenum, zone::z_name, zone::z_nrules, zone::z_rules, zone::z_save, zone::z_stdoff, zone::z_untilrule, zone::z_untiltime, ZIC_MAX, ZIC_MIN, ZIC_VERSION, and ZIC_VERSION_PRE_2013.

Referenced by main().

 {
     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);
                  */
                 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 &&
                         yearistype(year, rp->r_yrtype);
                     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);
 }

◆ puttzcode()

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

static

Definition at line 1981 of file zic.c.

References buf, and convert().

Referenced by puttzcodepass(), and writezone().

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

◆ puttzcodepass()

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

static

Definition at line 1990 of file zic.c.

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

Referenced by writezone().

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

◆ rcomp()

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

static

Definition at line 1141 of file zic.c.

References rule::r_name.

Referenced by associate().

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

◆ rpytime()

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

static

Definition at line 3806 of file zic.c.

References _, DC_DOWGEQ, DC_DOWLEQ, EPOCH_WDAY, EPOCH_YEAR, error(), EXIT_FAILURE, i, isleap, LDAYSPERWEEK, max_time, min_time, oadd(), rule::r_dayofmonth, rule::r_dycode, rule::r_month, rule::r_tod, rule::r_wday, SECSPERDAY, SECSPERREPEAT, tadd(), TM_FEBRUARY, TM_JANUARY, warning(), YEARSPERREPEAT, ZIC_MAX, and ZIC_MIN.

Referenced by inzsub(), and outzone().

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

◆ rule_cmp()

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

static

Definition at line 2764 of file zic.c.

References rule::r_dayofmonth, rule::r_hiyear, and rule::r_month.

Referenced by stringzone().

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

◆ 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 1783 of file zic.c.

References _, byword(), DC_DOM, DC_DOWGEQ, DC_DOWLEQ, ecpyalloc(), error(), EXIT_FAILURE, fprintf, free, gethms(), lookup::l_value, lowerit(), rule::r_dayofmonth, rule::r_dycode, rule::r_hiwasnum, rule::r_hiyear, rule::r_lowasnum, rule::r_loyear, rule::r_month, rule::r_tod, rule::r_todisstd, rule::r_todisut, rule::r_wday, rule::r_yrtype, warning(), YR_MAXIMUM, YR_MINIMUM, YR_ONLY, ZIC_MAX, and ZIC_MIN.

Referenced by inrule(), and inzsub().

 {
     const struct lookup *lp;
     const char *cp;
     char       *dp;
     char       *ep;
     char        xs;
 
     /* PG: year_tmp is to avoid sscanf portability issues */
     int         year_tmp;
 
     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, "%d%c", &year_tmp, &xs) == 1)
         rp->r_loyear = year_tmp;
     else
     {
         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, "%d%c", &year_tmp, &xs) == 1)
         rp->r_hiyear = year_tmp;
     else
     {
         error(_("invalid ending year"));
         return;
     }
     if (rp->r_loyear > rp->r_hiyear)
     {
         error(_("starting year greater than ending year"));
         return;
     }
     if (*typep == '\0')
         rp->r_yrtype = NULL;
     else
     {
         if (rp->r_loyear == rp->r_hiyear)
         {
             error(_("typed single year"));
             return;
         }
         warning(_("year type \"%s\" is obsolete; use \"-\" instead"),
                 typep);
         rp->r_yrtype = ecpyalloc(typep);
     }
 
     /*
      * 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);
 }

◆ shellquote()

static char* shellquote	(	char *	b,
		char const *	s
	)

static

Definition at line 3424 of file zic.c.

Referenced by yearistype().

 {
     *b++ = '\'';
     while (*s)
     {
         if (*s == '\'')
             *b++ = '\'', *b++ = '\\', *b++ = '\'';
         *b++ = *s++;
     }
     *b++ = '\'';
     return b;
 }

◆ size_product()

static size_t size_product	(	size_t	nitems,
		size_t	itemsize
	)

static

Definition at line 412 of file zic.c.

References _, and memory_exhausted().

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

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

◆ stringoffset()

static int stringoffset	(	char *	result,
		zic_t	offset
	)

static

Definition at line 2649 of file zic.c.

References DAYSPERWEEK, HOURSPERDAY, MINSPERHOUR, SECSPERMIN, and sprintf.

Referenced by stringrule(), and stringzone().

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

◆ stringrule()

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

static

Definition at line 2683 of file zic.c.

References compat, DAYSPERWEEK, DC_DOM, DC_DOWGEQ, DC_DOWLEQ, MINSPERHOUR, rule::r_dayofmonth, rule::r_dycode, rule::r_isdst, rule::r_month, rule::r_tod, rule::r_todisstd, rule::r_todisut, rule::r_wday, SECSPERDAY, SECSPERMIN, sprintf, stringoffset(), and TM_FEBRUARY.

Referenced by stringzone().

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

◆ stringzone()

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

static

Definition at line 2778 of file zic.c.

References compat, DC_DOM, doabbr(), i, MINSPERHOUR, rule::r_abbrvar, rule::r_dayofmonth, rule::r_dycode, rule::r_hiwasnum, rule::r_hiyear, rule::r_isdst, rule::r_month, rule::r_save, rule::r_tod, rule::r_todisstd, rule::r_todisut, rule::r_yrtype, rule_cmp(), SECSPERDAY, SECSPERMIN, stringoffset(), stringrule(), TM_DECEMBER, TM_JANUARY, zone::z_isdst, zone::z_nrules, zone::z_rules, zone::z_stdoff, and ZIC_MAX.

Referenced by outzone().

 {
     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_yrtype != NULL)
             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;
 }

◆ tadd()

static zic_t tadd	(	zic_t	t1,
		zic_t	t2
	)

static

Definition at line 3777 of file zic.c.

References max_time, min_time, and time_overflow().

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

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

◆ time_overflow()

static void time_overflow ( void )

static

Definition at line 3762 of file zic.c.

References _, error(), and EXIT_FAILURE.

Referenced by oadd(), and tadd().

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

◆ timerange_option()

static bool timerange_option ( char * timerange )

static

Definition at line 590 of file zic.c.

References max_time, min_time, PG_INT64_MAX, PG_INT64_MIN, and strtoimax.

Referenced by main().

 {
     int64       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 == PG_INT64_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 == PG_INT64_MIN)
             return false;
         hi -= !(hi == PG_INT64_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;
 }

◆ updateminmax()

static void updateminmax ( const zic_t x )

static

Definition at line 2640 of file zic.c.

Referenced by outzone().

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

◆ usage()

static void usage	(	FILE *	stream,
		int	status
	)

static

Definition at line 537 of file zic.c.

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

Referenced by main().

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

◆ verror()

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

static

Definition at line 482 of file zic.c.

References _, fprintf, and vfprintf.

Referenced by error(), and warning().

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

◆ want_bloat()

static bool want_bloat ( void )

static

Definition at line 633 of file zic.c.

References bloat.

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

 {
     return 0 <= bloat;
 }

◆ warning()

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

static

Definition at line 509 of file zic.c.

References _, generate_unaccent_rules::args, fprintf, and verror().

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

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

◆ writezone()

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

static

Definition at line 2049 of file zic.c.

References _, addtype(), attype::at, atcomp(), attypes, timerange::base, close_file(), convert(), timerange::count, timerange::defaulttype, DO, emalloc(), error(), EXIT_FAILURE, fprintf, free, i, INT64_FORMAT, timerange::leapbase, leapcnt, timerange::leapcount, limitrange(), lo_time, max_time, MAXALIGN, mkdirs(), PG_INT32_MAX, PG_INT32_MIN, puttzcode(), puttzcodepass(), qsort, size_product(), generate_unaccent_rules::stdout, strerror, tadd(), timecnt, tm, generate_unaccent_rules::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, want_bloat(), warning(), WORK_AROUND_QTBUG_53071, and ZIC_MAX.

Referenced by outzone().

 {
     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(MAXALIGN(size_product(nats, sizeof *ats + 1)));
     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, PG_INT32_MIN, PG_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
              * PG_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 <= PG_INT32_MIN
                                ? range64.defaulttype
                                : range32.defaulttype);
 
             thistimei = range32.base;
             thistimecnt = range32.count;
             toomanytimes = thistimecnt >> 31 >> 1 != 0;
             thisleapi = range32.leapbase;
             thisleapcnt = range32.leapcount;
             locut = PG_INT32_MIN < lo_time;
             hicut = hi_time < PG_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);

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ DC_DOM

◆ DC_DOWGEQ

◆ DC_DOWLEQ

◆ DO

◆ LC_LEAP

◆ LC_LINK

◆ LC_RULE

◆ LC_ZONE

◆ LDAYSPERWEEK

◆ LEAP_FIELDS

◆ LF_FROM

◆ LF_TO

◆ LINK_FIELDS

◆ linkat

◆ LP_CORR

◆ LP_DAY

◆ LP_MONTH

◆ LP_ROLL

◆ LP_TIME

◆ LP_YEAR

◆ MKDIR_UMASK

◆ RF_ABBRVAR

◆ RF_COMMAND

◆ RF_DAY

◆ RF_HIYEAR

◆ RF_LOYEAR

◆ RF_MONTH

◆ RF_NAME

◆ RF_SAVE

◆ RF_TOD

◆ RULE_FIELDS

◆ TIME_T_BITS_IN_FILE

◆ YR_MAXIMUM

◆ YR_MINIMUM

◆ YR_ONLY

◆ 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

◆ ZIC_BLOAT_DEFAULT

◆ ZIC_MAX

◆ ZIC_MAX_ABBR_LEN_WO_WARN

◆ ZIC_MIN

◆ ZIC_VERSION

◆ ZIC_VERSION_PRE_2013

◆ ZONE_MAXFIELDS

◆ ZONE_MINFIELDS

◆ ZONEC_MAXFIELDS

◆ ZONEC_MINFIELDS

Typedef Documentation

◆ lineno_t

◆ zic_t

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

Function Documentation

◆ abbroffset()

◆ addtt()

◆ addtype()

◆ adjleap()

◆ associate()

◆ atcomp()