#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

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_GMTOFF 2

#define	ZF_RULE 3

#define	ZF_FORMAT 4

#define	ZF_TILYEAR 5

#define	ZF_TILMONTH 6

#define	ZF_TILDAY 7

#define	ZF_TILTIME 8

#define	ZONE_MINFIELDS 5

#define	ZONE_MAXFIELDS 9

#define	ZFC_GMTOFF 0

#define	ZFC_RULE 1

#define	ZFC_FORMAT 2

#define	ZFC_TILYEAR 3

#define	ZFC_TILMONTH 4

#define	ZFC_TILDAY 5

#define	ZFC_TILTIME 6

#define	ZONEC_MINFIELDS 3

#define	ZONEC_MAXFIELDS 7

#define	RF_NAME 1

#define	RF_LOYEAR 2

#define	RF_HIYEAR 3

#define	RF_COMMAND 4

#define	RF_MONTH 5

#define	RF_DAY 6

#define	RF_TOD 7

#define	RF_STDOFF 8

#define	RF_ABBRVAR 9

#define	RULE_FIELDS 10

#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	BIG_BANG (- (((zic_t) 1) << 59))

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

enum	{ WORK_AROUND_GNOME_BUG_730332 = true }

enum	{ YEAR_BY_YEAR_ZONE = 1 }

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, bool)

static zic_t	getstdoff (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)

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	puttzcode64 (const zic_t val, FILE *const fp)

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

static bool	is32 (const zic_t x)

static void	writezone (const char const name, const char const string, char version)

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 stdoff, bool doquotes)

static void	updateminmax (const zic_t x)

static int	stringoffset (char *result, zic_t offset)

static int	stringrule (char result, const struct rule const rp, const zic_t dstoff, const zic_t gmtoff)

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	gmtoffs [TZ_MAX_TYPES]

static char	isdsts [TZ_MAX_TYPES]

static unsigned char	abbrinds [TZ_MAX_TYPES]

static bool	ttisstds [TZ_MAX_TYPES]

static bool	ttisgmts [TZ_MAX_TYPES]

static char	chars [TZ_MAX_CHARS]

static zic_t	trans [TZ_MAX_LEAPS]

static zic_t	corr [TZ_MAX_LEAPS]

static char	roll [TZ_MAX_LEAPS]

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 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 const zic_t	early_time

Macro Definition Documentation

◆ BIG_BANG

#define BIG_BANG (- (((zic_t) 1) << 59))

Definition at line 1024 of file zic.c.

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

Referenced by infile().

◆ LC_LINK

#define LC_LINK 2

Definition at line 202 of file zic.c.

Referenced by infile().

◆ LC_RULE

#define LC_RULE 0

Definition at line 200 of file zic.c.

Referenced by infile().

◆ LC_ZONE

#define LC_ZONE 1

Definition at line 201 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 267 of file zic.c.

Referenced by inleap().

◆ LF_FROM

#define LF_FROM 1

Definition at line 253 of file zic.c.

Referenced by inlink().

◆ LF_TO

#define LF_TO 2

Definition at line 254 of file zic.c.

Referenced by inlink().

◆ LINK_FIELDS

#define LINK_FIELDS 3

Definition at line 255 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 39 of file zic.c.

Referenced by hardlinkerr().

◆ LP_CORR

#define LP_CORR 5

Definition at line 265 of file zic.c.

Referenced by inleap().

◆ LP_DAY

#define LP_DAY 3

Definition at line 263 of file zic.c.

Referenced by inleap().

◆ LP_MONTH

#define LP_MONTH 2

Definition at line 262 of file zic.c.

Referenced by inleap().

◆ LP_ROLL

#define LP_ROLL 6

Definition at line 266 of file zic.c.

Referenced by inleap().

◆ LP_TIME

#define LP_TIME 4

Definition at line 264 of file zic.c.

Referenced by inleap().

◆ LP_YEAR

#define LP_YEAR 1

Definition at line 261 of file zic.c.

Referenced by inleap().

◆ MKDIR_UMASK

#define MKDIR_UMASK 0755

Definition at line 35 of file zic.c.

Referenced by mkdirs().

◆ RF_ABBRVAR

#define RF_ABBRVAR 9

Definition at line 246 of file zic.c.

Referenced by inrule().

◆ RF_COMMAND

#define RF_COMMAND 4

Definition at line 241 of file zic.c.

Referenced by inrule().

◆ RF_DAY

#define RF_DAY 6

Definition at line 243 of file zic.c.

Referenced by inrule().

◆ RF_HIYEAR

#define RF_HIYEAR 3

Definition at line 240 of file zic.c.

Referenced by inrule().

◆ RF_LOYEAR

#define RF_LOYEAR 2

Definition at line 239 of file zic.c.

Referenced by inrule().

◆ RF_MONTH

#define RF_MONTH 5

Definition at line 242 of file zic.c.

Referenced by inrule().

◆ RF_NAME

#define RF_NAME 1

Definition at line 238 of file zic.c.

Referenced by inrule().

◆ RF_STDOFF

#define RF_STDOFF 8

Definition at line 245 of file zic.c.

Referenced by inrule().

◆ RF_TOD

#define RF_TOD 7

Definition at line 244 of file zic.c.

Referenced by inrule().

◆ RULE_FIELDS

#define RULE_FIELDS 10

Definition at line 247 of file zic.c.

Referenced by inrule().

◆ TIME_T_BITS_IN_FILE

#define TIME_T_BITS_IN_FILE 64

Definition at line 996 of file zic.c.

◆ YR_MAXIMUM

#define YR_MAXIMUM 1

Definition at line 274 of file zic.c.

Referenced by rulesub().

◆ YR_MINIMUM

#define YR_MINIMUM 0

Definition at line 273 of file zic.c.

Referenced by rulesub().

◆ YR_ONLY

#define YR_ONLY 2

Definition at line 275 of file zic.c.

Referenced by rulesub().

◆ ZF_FORMAT

#define ZF_FORMAT 4

Definition at line 212 of file zic.c.

Referenced by inzsub().

◆ ZF_GMTOFF

#define ZF_GMTOFF 2

Definition at line 210 of file zic.c.

Referenced by inzsub().

◆ ZF_NAME

#define ZF_NAME 1

Definition at line 209 of file zic.c.

Referenced by inzone(), and inzsub().

◆ ZF_RULE

#define ZF_RULE 3

Definition at line 211 of file zic.c.

Referenced by inzsub().

◆ ZF_TILDAY

#define ZF_TILDAY 7

Definition at line 215 of file zic.c.

Referenced by inzsub().

◆ ZF_TILMONTH

#define ZF_TILMONTH 6

Definition at line 214 of file zic.c.

Referenced by inzsub().

◆ ZF_TILTIME

#define ZF_TILTIME 8

Definition at line 216 of file zic.c.

Referenced by inzsub().

◆ ZF_TILYEAR

#define ZF_TILYEAR 5

Definition at line 213 of file zic.c.

Referenced by inzsub().

◆ ZFC_FORMAT

#define ZFC_FORMAT 2

Definition at line 226 of file zic.c.

Referenced by inzsub().

◆ ZFC_GMTOFF

#define ZFC_GMTOFF 0

Definition at line 224 of file zic.c.

Referenced by inzsub().

◆ ZFC_RULE

#define ZFC_RULE 1

Definition at line 225 of file zic.c.

Referenced by inzsub().

◆ ZFC_TILDAY

#define ZFC_TILDAY 5

Definition at line 229 of file zic.c.

Referenced by inzsub().

◆ ZFC_TILMONTH

#define ZFC_TILMONTH 4

Definition at line 228 of file zic.c.

Referenced by inzsub().

◆ ZFC_TILTIME

#define ZFC_TILTIME 6

Definition at line 230 of file zic.c.

Referenced by inzsub().

◆ ZFC_TILYEAR

#define ZFC_TILYEAR 3

Definition at line 227 of file zic.c.

Referenced by inzsub().

◆ ZIC_MAX

#define ZIC_MAX PG_INT64_MAX

Definition at line 25 of file zic.c.

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

◆ ZIC_MAX_ABBR_LEN_WO_WARN

#define ZIC_MAX_ABBR_LEN_WO_WARN 6

Definition at line 28 of file zic.c.

Referenced by newabbr().

◆ ZIC_MIN

#define ZIC_MIN PG_INT64_MIN

Definition at line 24 of file zic.c.

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

◆ ZIC_VERSION

#define ZIC_VERSION '3'

Definition at line 21 of file zic.c.

Referenced by outzone().

◆ ZIC_VERSION_PRE_2013

#define ZIC_VERSION_PRE_2013 '2'

Definition at line 20 of file zic.c.

Referenced by outzone().

◆ ZONE_MAXFIELDS

#define ZONE_MAXFIELDS 9

Definition at line 218 of file zic.c.

Referenced by inzone().

◆ ZONE_MINFIELDS

#define ZONE_MINFIELDS 5

Definition at line 217 of file zic.c.

◆ ZONEC_MAXFIELDS

#define ZONEC_MAXFIELDS 7

Definition at line 232 of file zic.c.

Referenced by inzcont().

◆ ZONEC_MINFIELDS

#define ZONEC_MINFIELDS 3

Definition at line 231 of file zic.c.

Typedef Documentation

◆ lineno_t

typedef int lineno_t

Definition at line 57 of file zic.c.

◆ zic_t

typedef int64 zic_t

Definition at line 23 of file zic.c.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
PERCENT_Z_LEN_BOUND

Definition at line 160 of file zic.c.

161 {

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

PERCENT_Z_LEN_BOUND

Definition: zic.c:162

◆ 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

◆ anonymous enum

anonymous enum

Enumerator
WORK_AROUND_GNOME_BUG_730332

Definition at line 1035 of file zic.c.

1036 {

1037 WORK_AROUND_GNOME_BUG_730332 = true};

WORK_AROUND_GNOME_BUG_730332

Definition: zic.c:1037

◆ anonymous enum

anonymous enum

Enumerator
YEAR_BY_YEAR_ZONE

Definition at line 2587 of file zic.c.

2588 {

2589 YEAR_BY_YEAR_ZONE = 1};

YEAR_BY_YEAR_ZONE

Definition: zic.c:2589

Function Documentation

◆ abbroffset()

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

static

Definition at line 2362 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 3110 of file zic.c.

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

Referenced by outzone().

 {
     if (starttime <= early_time
         || (timecnt == 1 && attypes[0].at < early_time))
     {
         gmtoffs[0] = gmtoffs[type];
         isdsts[0] = isdsts[type];
         ttisstds[0] = ttisstds[type];
         ttisgmts[0] = ttisgmts[type];
         if (abbrinds[type] != 0)
             strcpy(chars, &chars[abbrinds[type]]);
         abbrinds[0] = 0;
         charcnt = strlen(chars) + 1;
         typecnt = 1;
         timecnt = 0;
         type = 0;
     }
     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	gmtoff,
		char const *	abbr,
		bool	isdst,
		bool	ttisstd,
		bool	ttisgmt
	)

static

Definition at line 3135 of file zic.c.

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

Referenced by outzone(), and writezone().

 {
     int         i,
                 j;
 
     /*
      * See if there's already an entry for this zone type. If so, just return
      * its index.
      */
     for (i = 0; i < typecnt; ++i)
     {
         if (gmtoff == gmtoffs[i] && isdst == isdsts[i] &&
             strcmp(abbr, &chars[abbrinds[i]]) == 0 &&
             ttisstd == ttisstds[i] &&
             ttisgmt == ttisgmts[i])
             return i;
     }
 
     /*
      * There isn't one; add a new one, unless there are already too many.
      */
     if (typecnt >= TZ_MAX_TYPES)
     {
         error(_("too many local time types"));
         exit(EXIT_FAILURE);
     }
     if (!(-1L - 2147483647L <= gmtoff && gmtoff <= 2147483647L))
     {
         error(_("UT offset out of range"));
         exit(EXIT_FAILURE);
     }
     gmtoffs[i] = gmtoff;
     isdsts[i] = isdst;
     ttisstds[i] = ttisstd;
     ttisgmts[i] = ttisgmt;
 
     for (j = 0; j < charcnt; ++j)
         if (strcmp(&chars[j], abbr) == 0)
             break;
     if (j == charcnt)
         newabbr(abbr);
     abbrinds[i] = j;
     ++typecnt;
     return i;
 }

◆ adjleap()

static void adjleap ( void )

static

Definition at line 3211 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 1097 of file zic.c.

References _, eat(), error(), EXIT_FAILURE, getstdoff(), 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_stdoff.

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_stdoff = getstdoff(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 1930 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 3466 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 */
         }
 
     /* Warn about any backward-compatibility issue with pre-2017c zic.  */
     if (foundlp)
     {
         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 553 of file zic.c.

References _, EXIT_FAILURE, 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 3429 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 3455 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 520 of file zic.c.

References _, EXIT_FAILURE, 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 754 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 1890 of file zic.c.

References i.

Referenced by ExecEvalConvertRowtype(), ExecInitExprRec(), fmtfloat(), fmtint(), fmtptr(), get_rule_expr(), 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 1901 of file zic.c.

References i.

Referenced by puttzcode64().

 {
     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	stdoff,
		bool	doquotes
	)

static

Definition at line 2406 of file zic.c.

References abbroffset(), format, is_alpha(), memmove, PERCENT_Z_LEN_BOUND, zone::z_format, zone::z_format_specifier, and zone::z_gmtoff.

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_gmtoff + stdoff);
         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 899 of file zic.c.

References _, close_file(), ENOTSUP, EXIT_FAILURE, free, hardlinkerr(), itsdir(), itssymlink(), mkdirs(), 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 475 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 466 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 439 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 427 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 433 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 497 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(), 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 3532 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,
		bool	signable
	)

static

Definition at line 1285 of file zic.c.

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

Referenced by getstdoff(), 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 (!signable)
         sign = 1;
     else 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));
 }

◆ getstdoff()

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

static

Definition at line 1365 of file zic.c.

References _, and gethms().

Referenced by associate(), and inrule().

 {
     int         dst = -1;
     zic_t       stdoff;
     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;
         }
     }
     stdoff = gethms(field, _("invalid saved time"), true);
     *isdst = dst < 0 ? stdoff != 0 : dst;
     return stdoff;
 }

◆ growalloc()

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

static

Definition at line 445 of file zic.c.

References _, erealloc(), memory_exhausted(), PTRDIFF_MAX, SIZE_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 891 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 1182 of file zic.c.

References _, buf, byword(), close_file(), eat(), error(), EXIT_FAILURE, 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 1569 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"), false);
     cp = fields[LP_CORR];
     {
         bool        positive;
         int         count;
 
         if (strcmp(cp, "") == 0)
         {                       /* infile() turns "-" into "" */
             positive = false;
             count = 1;
         }
         else if (strcmp(cp, "+") == 0)
         {
             positive = 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 1689 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 1393 of file zic.c.

References _, ecpyalloc(), error(), filename, getstdoff(), growalloc(), linenum, rule::r_abbrvar, rule::r_filename, rule::r_isdst, rule::r_linenum, rule::r_name, rule::r_stdoff, RF_ABBRVAR, RF_COMMAND, RF_DAY, RF_HIYEAR, RF_LOYEAR, RF_MONTH, RF_NAME, RF_STDOFF, 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;
     }
     if (*fields[RF_NAME] == '\0')
     {
         error(_("nameless rule"));
         return;
     }
     r.r_filename = filename;
     r.r_linenum = linenum;
     r.r_stdoff = getstdoff(fields[RF_STDOFF], &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 1459 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 1421 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 1470 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_gmtoff, zone::z_linenum, zone::z_name, zone::z_rule, zone::z_untilrule, zone::z_untiltime, ZF_FORMAT, ZF_GMTOFF, ZF_NAME, ZF_RULE, ZF_TILDAY, ZF_TILMONTH, ZF_TILTIME, ZF_TILYEAR, ZFC_FORMAT, ZFC_GMTOFF, ZFC_RULE, ZFC_TILDAY, ZFC_TILMONTH, ZFC_TILTIME, and ZFC_TILYEAR.

Referenced by inzcont(), and inzone().

 {
     char       *cp;
     char       *cp1;
     static struct zone z;
     int         i_gmtoff,
                 i_rule,
                 i_format;
     int         i_untilyear,
                 i_untilmonth;
     int         i_untilday,
                 i_untiltime;
     bool        hasuntil;
 
     if (iscont)
     {
         i_gmtoff = ZFC_GMTOFF;
         i_rule = ZFC_RULE;
         i_format = ZFC_FORMAT;
         i_untilyear = ZFC_TILYEAR;
         i_untilmonth = ZFC_TILMONTH;
         i_untilday = ZFC_TILDAY;
         i_untiltime = ZFC_TILTIME;
         z.z_name = NULL;
     }
     else if (!namecheck(fields[ZF_NAME]))
         return false;
     else
     {
         i_gmtoff = ZF_GMTOFF;
         i_rule = ZF_RULE;
         i_format = ZF_FORMAT;
         i_untilyear = ZF_TILYEAR;
         i_untilmonth = ZF_TILMONTH;
         i_untilday = ZF_TILDAY;
         i_untiltime = ZF_TILTIME;
         z.z_name = ecpyalloc(fields[ZF_NAME]);
     }
     z.z_filename = filename;
     z.z_linenum = linenum;
     z.z_gmtoff = gethms(fields[i_gmtoff], _("invalid UT offset"), true);
     if ((cp = strchr(fields[i_format], '%')) != 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;
 }

◆ is32()

static bool is32 ( const zic_t x )

static

Definition at line 1939 of file zic.c.

Referenced by writezone().

 {
     return x == ((zic_t) ((int32) x));
 }

◆ is_alpha()

static bool is_alpha ( char a )

static

Definition at line 3301 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 3283 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 3438 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 1045 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 1070 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 3182 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);
 }

◆ link()

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

Referenced by durable_link_or_rename(), mkdirs(), and remove_from_unowned_list().

◆ lowerit()

static char lowerit ( char a )

static

Definition at line 3366 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 581 of file zic.c.

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

 {
     int         c,
                 k;
     ptrdiff_t   i,
                 j;
 
 #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, "d:l:L:p:Pst:vy:")) != EOF && c != -1)
         switch (c)
         {
             default:
                 usage(stderr, EXIT_FAILURE);
             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 's':
                 warning(_("-s ignored"));
                 break;
         }
     if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
         usage(stderr, EXIT_FAILURE);    /* usage message by request */
     if (directory == NULL)
         directory = "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 419 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 404 of file zic.c.

References _, and EXIT_FAILURE.

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 3752 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 798 of file zic.c.

References _, componentcheck(), emalloc(), i, memmove, name, SIZE_MAX, 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 3714 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 3579 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 2730 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_stdoff, rule::r_temp, rule::r_tod, rule::r_todisgmt, rule::r_todisstd, rule::r_todo, rule::r_yrtype, rpytime(), stringzone(), tadd(), timecnt, TM_JANUARY, generate_unaccent_rules::type, updateminmax(), warning(), writezone(), YEAR_BY_YEAR_ZONE, yearistype(), YEARSPERREPEAT, zone::z_filename, zone::z_format, zone::z_gmtoff, zone::z_isdst, zone::z_linenum, zone::z_name, zone::z_nrules, zone::z_rules, 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       gmtoff;
     zic_t       stdoff;
     zic_t       year;
     zic_t       startoff;
     bool        startttisstd;
     bool        startttisgmt;
     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;
 
     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;
     startttisgmt = 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 || compat == YEAR_BY_YEAR_ZONE;
     if (noise)
     {
         if (!*envvar)
             warning("%s %s",
                     _("no POSIX environment variable for zone"),
                     zpfirst->z_name);
         else if (compat != 0 && compat != YEAR_BY_YEAR_ZONE)
         {
             /*
              * 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;
         }
     }
 
     /*
      * For the benefit of older systems, generate data from 1900 through 2038.
      */
     if (min_year > 1900)
         min_year = 1900;
     max_year0 = max_year;
     if (max_year < 2038)
         max_year = 2038;
     for (i = 0; i < zonecount; ++i)
     {
         /*
          * A guess that may well be corrected later.
          */
         stdoff = 0;
         zp = &zpfirst[i];
         usestart = i > 0 && (zp - 1)->z_untiltime > early_time;
         useuntil = i < (zonecount - 1);
         if (useuntil && zp->z_untiltime <= early_time)
             continue;
         gmtoff = zp->z_gmtoff;
         eat(zp->z_filename, zp->z_linenum);
         *startbuf = '\0';
         startoff = zp->z_gmtoff;
         if (zp->z_nrules == 0)
         {
             stdoff = zp->z_stdoff;
             doabbr(startbuf, zp, NULL, zp->z_isdst, stdoff, false);
             type = addtype(oadd(zp->z_gmtoff, stdoff),
                            startbuf, zp->z_isdst, startttisstd,
                            startttisgmt);
             if (usestart)
             {
                 addtt(starttime, type);
                 usestart = false;
             }
             else
                 addtt(early_time, 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 gmtoff
                          * and stdoff values.
                          */
                         untiltime = zp->z_untiltime;
                         if (!zp->z_untilrule.r_todisgmt)
                             untiltime = tadd(untiltime,
                                              -gmtoff);
                         if (!zp->z_untilrule.r_todisstd)
                             untiltime = tadd(untiltime,
                                              -stdoff);
                     }
 
                     /*
                      * Find the rule (of those to do, if any) 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_todisgmt ? 0 : gmtoff;
                         if (!rp->r_todisstd)
                             offset = oadd(offset, stdoff);
                         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;
                     stdoff = rp->r_stdoff;
                     if (usestart && ktime == starttime)
                         usestart = false;
                     if (usestart)
                     {
                         if (ktime < starttime)
                         {
                             startoff = oadd(zp->z_gmtoff,
                                             stdoff);
                             doabbr(startbuf, zp,
                                    rp->r_abbrvar,
                                    rp->r_isdst,
                                    rp->r_stdoff,
                                    false);
                             continue;
                         }
                         if (*startbuf == '\0' &&
                             startoff == oadd(zp->z_gmtoff,
                                              stdoff))
                         {
                             doabbr(startbuf,
                                    zp,
                                    rp->r_abbrvar,
                                    rp->r_isdst,
                                    rp->r_stdoff,
                                    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_stdoff, false);
                     offset = oadd(zp->z_gmtoff, rp->r_stdoff);
                     type = addtype(offset, ab, rp->r_isdst,
                                    rp->r_todisstd, rp->r_todisgmt);
                     if (rp->r_hiyear == ZIC_MAX
                         && !(0 <= lastatmax
                              && ktime < attypes[lastatmax].at))
                         lastatmax = timecnt;
                     addtt(ktime, type);
                 }
             }
         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
                 addtt(starttime,
                       addtype(startoff, startbuf,
                               startoff != zp->z_gmtoff,
                               startttisstd,
                               startttisgmt));
         }
 
         /*
          * Now we may get to set starttime for the next zone line.
          */
         if (useuntil)
         {
             startttisstd = zp->z_untilrule.r_todisstd;
             startttisgmt = zp->z_untilrule.r_todisgmt;
             starttime = zp->z_untiltime;
             if (!startttisstd)
                 starttime = tadd(starttime, -stdoff);
             if (!startttisgmt)
                 starttime = tadd(starttime, -gmtoff);
         }
     }
     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[0], i = 1; i < timecnt; i++)
             if (attypes[i].at > lastat->at)
                 lastat = &attypes[i];
         if (lastat->at < rpytime(&xr, max_year - 1))
         {
             addtt(rpytime(&xr, max_year + 1), typecnt - 1);
             attypes[timecnt - 1].dontmerge = true;
         }
     }
     writezone(zpfirst->z_name, envvar, version);
     free(startbuf);
     free(ab);
     free(envvar);
 }

◆ puttzcode()

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

static

Definition at line 1912 of file zic.c.

References buf, and convert().

Referenced by writezone().

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

◆ puttzcode64()

static void puttzcode64	(	const zic_t	val,
		FILE *const	fp
	)

static

Definition at line 1921 of file zic.c.

References buf, and convert64().

Referenced by writezone().

 {
     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 1090 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 3616 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, tadd(), TM_FEBRUARY, TM_JANUARY, warning(), 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;
     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 2574 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 1714 of file zic.c.

References _, byword(), DC_DOM, DC_DOWGEQ, DC_DOWLEQ, ecpyalloc(), error(), EXIT_FAILURE, 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_todisgmt, rule::r_todisstd, 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_todisgmt = false;
     dp = ecpyalloc(timep);
     if (*dp != '\0')
     {
         ep = dp + strlen(dp) - 1;
         switch (lowerit(*ep))
         {
             case 's':           /* Standard */
                 rp->r_todisstd = true;
                 rp->r_todisgmt = false;
                 *ep = '\0';
                 break;
             case 'w':           /* Wall */
                 rp->r_todisstd = false;
                 rp->r_todisgmt = false;
                 *ep = '\0';
                 break;
             case 'g':           /* Greenwich */
             case 'u':           /* Universal */
             case 'z':           /* Zulu */
                 rp->r_todisstd = true;
                 rp->r_todisgmt = true;
                 *ep = '\0';
                 break;
         }
     }
     rp->r_tod = gethms(dp, _("invalid time of day"), false);
     free(dp);
 
     /*
      * Year work.
      */
     cp = loyearp;
     lp = byword(cp, begin_years);
     rp->r_lowasnum = lp == NULL;
     if (!rp->r_lowasnum)
         switch (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 3234 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 411 of file zic.c.

References _, memory_exhausted(), and SIZE_MAX.

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

References DAYSPERWEEK, HOURSPERDAY, MINSPERHOUR, and SECSPERMIN.

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,
		const struct rule *const	rp,
		const zic_t	dstoff,
		const zic_t	gmtoff
	)

static

Definition at line 2492 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_todisgmt, rule::r_todisstd, rule::r_wday, SECSPERDAY, SECSPERMIN, 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_todisgmt)
         tod += gmtoff;
     if (rp->r_todisstd && !rp->r_isdst)
         tod += dstoff;
     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 2592 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_stdoff, rule::r_tod, rule::r_todisgmt, rule::r_todisstd, rule::r_yrtype, rule_cmp(), SECSPERDAY, SECSPERMIN, stringoffset(), stringrule(), TM_DECEMBER, TM_JANUARY, YEAR_BY_YEAR_ZONE, zone::z_gmtoff, zone::z_isdst, zone::z_nrules, zone::z_rules, 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';
     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;
         }
 
         /*
          * Horrid special case: if year is 2037, presume this is a zone
          * handled on a year-by-year basis; do not try to apply a rule to the
          * zone.
          */
         if (stdrp != NULL && stdrp->r_hiyear == 2037)
             return YEAR_BY_YEAR_ZONE;
 
         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_todisgmt = false;
             dstr.r_isdst = stdrp->r_isdst;
             dstr.r_stdoff = stdrp->r_stdoff;
             dstr.r_abbrvar = stdrp->r_abbrvar;
             stdr.r_month = TM_DECEMBER;
             stdr.r_dycode = DC_DOM;
             stdr.r_dayofmonth = 31;
             stdr.r_tod = SECSPERDAY + stdrp->r_stdoff;
             stdr.r_todisstd = stdr.r_todisgmt = false;
             stdr.r_isdst = false;
             stdr.r_stdoff = 0;
             stdr.r_abbrvar
                 = (stdabbrrp ? stdabbrrp->r_abbrvar : "");
             dstrp = &dstr;
             stdrp = &stdr;
         }
     }
     if (stdrp == NULL && (zp->z_nrules != 0 || zp->z_isdst))
         return -1;
     abbrvar = (stdrp == NULL) ? "" : stdrp->r_abbrvar;
     len = doabbr(result, zp, abbrvar, false, 0, true);
     offsetlen = stringoffset(result + len, -zp->z_gmtoff);
     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_stdoff, true);
     if (dstrp->r_stdoff != SECSPERMIN * MINSPERHOUR)
     {
         offsetlen = stringoffset(result + len,
                                  -(zp->z_gmtoff + dstrp->r_stdoff));
         if (!offsetlen)
         {
             result[0] = '\0';
             return -1;
         }
         len += offsetlen;
     }
     result[len++] = ',';
     c = stringrule(result + len, dstrp, dstrp->r_stdoff, zp->z_gmtoff);
     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_stdoff, zp->z_gmtoff);
     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 3587 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 3572 of file zic.c.

References _, error(), and EXIT_FAILURE.

Referenced by oadd(), and tadd().

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

◆ updateminmax()

static void updateminmax ( const zic_t x )

static

Definition at line 2449 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 536 of file zic.c.

References _, close_file(), and EXIT_SUCCESS.

Referenced by main().

 {
     fprintf(stream,
             _("%s: usage is %s [ --version ] [ --help ] [ -v ] [ -P ] \\\n"
               "\t[ -l localtime ] [ -p posixrules ] [ -d directory ] \\\n"
               "\t[ -t localtime-link ] [ -L leapseconds ] [ 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 481 of file zic.c.

References _.

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

◆ warning()

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

static

Definition at line 508 of file zic.c.

References _, generate_unaccent_rules::args, 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
	)

static

Definition at line 1945 of file zic.c.

References _, addtype(), attype::at, atcomp(), attypes, close_file(), convert(), DO, emalloc(), error(), EXIT_FAILURE, free, GRANDPARENTED, i, INT64_FORMAT, is32(), leapcnt, mkdirs(), PG_INT32_MIN, puttzcode(), puttzcode64(), qsort, size_product(), 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_reserved, tzhead::tzh_timecnt, tzhead::tzh_ttisgmtcnt, tzhead::tzh_ttisstdcnt, tzhead::tzh_typecnt, tzhead::tzh_version, warning(), and WORK_AROUND_QTBUG_53071.

Referenced by outzone().

 {
     FILE       *fp;
     ptrdiff_t   i,
                 j;
     int         leapcnt32,
                 leapi32;
     ptrdiff_t   timecnt32,
                 timei32;
     int         pass;
     static const struct tzhead tzh0;
     static struct tzhead tzh;
     bool        dir_checked = false;
     zic_t       one = 1;
     zic_t       y2038_boundary = one << 31;
     ptrdiff_t   nats = timecnt + WORK_AROUND_QTBUG_53071;
     zic_t      *ats = emalloc(size_product(nats, sizeof *ats + 1));
     void       *typesptr = ats + nats;
     unsigned char *types = typesptr;
 
     /*
      * Sort.
      */
     if (timecnt > 1)
         qsort(attypes, timecnt, sizeof *attypes, atcomp);
 
     /*
      * Optimize.
      */
     {
         ptrdiff_t   fromi,
                     toi;
 
         toi = 0;
         fromi = 0;
         while (fromi < timecnt && attypes[fromi].at < early_time)
             ++fromi;
         for (; fromi < timecnt; ++fromi)
         {
             if (toi > 1 && ((attypes[fromi].at +
                              gmtoffs[attypes[toi - 1].type]) <=
                             (attypes[toi - 1].at +
                              gmtoffs[attypes[toi - 2].type])))
             {
                 attypes[toi - 1].type =
                     attypes[fromi].type;
                 continue;
             }
             if (toi == 0
                 || attypes[fromi].dontmerge
                 || attypes[toi - 1].type != attypes[fromi].type)
                 attypes[toi++] = attypes[fromi];
         }
         timecnt = toi;
     }
 
     if (noise && timecnt > 1200)
     {
         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;
     }
 
     /*
      * Work around QTBUG-53071 for time stamps less than y2038_boundary - 1,
      * by inserting a no-op transition at time y2038_boundary - 1. This works
      * only for timestamps before the boundary, which should be good enough in
      * practice as QTBUG-53071 should be long-dead by 2038.
      */
     if (WORK_AROUND_QTBUG_53071 && timecnt != 0
         && ats[timecnt - 1] < y2038_boundary - 1 && strchr(string, '<'))
     {
         ats[timecnt] = y2038_boundary - 1;
         types[timecnt] = types[timecnt - 1];
         timecnt++;
     }
 
     /*
      * Correct for leap seconds.
      */
     for (i = 0; i < timecnt; ++i)
     {
         j = leapcnt;
         while (--j >= 0)
             if (ats[i] > trans[j] - corr[j])
             {
                 ats[i] = tadd(ats[i], corr[j]);
                 break;
             }
     }
 
     /*
      * Figure out 32-bit-limited starts and counts.
      */
     timecnt32 = timecnt;
     timei32 = 0;
     leapcnt32 = leapcnt;
     leapi32 = 0;
     while (timecnt32 > 0 && !is32(ats[timecnt32 - 1]))
         --timecnt32;
     while (timecnt32 > 0 && !is32(ats[timei32]))
     {
         --timecnt32;
         ++timei32;
     }
 
     /*
      * Output an INT32_MIN "transition" if appropriate; see below.
      */
     if (timei32 > 0 && ats[timei32] > PG_INT32_MIN)
     {
         --timei32;
         ++timecnt32;
     }
     while (leapcnt32 > 0 && !is32(trans[leapcnt32 - 1]))
         --leapcnt32;
     while (leapcnt32 > 0 && !is32(trans[leapi32]))
     {
         --leapcnt32;
         ++leapi32;
     }
 
     /*
      * Remove old file, if any, to snap links.
      */
     if (remove(name) == 0)
         dir_checked = true;
     else if (errno != ENOENT)
     {
         const char *e = strerror(errno);
 
         fprintf(stderr, _("%s: 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         writetype[TZ_MAX_TYPES];
         int         typemap[TZ_MAX_TYPES];
         int         thistypecnt;
         char        thischars[TZ_MAX_CHARS];
         int         thischarcnt;
         bool        toomanytimes;
         int         indmap[TZ_MAX_CHARS];
 
         if (pass == 1)
         {
             thistimei = timei32;
             thistimecnt = timecnt32;
             toomanytimes = thistimecnt >> 31 >> 1 != 0;
             thisleapi = leapi32;
             thisleapcnt = leapcnt32;
         }
         else
         {
             thistimei = 0;
             thistimecnt = timecnt;
             toomanytimes = thistimecnt >> 31 >> 31 >> 2 != 0;
             thisleapi = 0;
             thisleapcnt = leapcnt;
         }
         if (toomanytimes)
             error(_("too many transition times"));
         thistimelim = thistimei + thistimecnt;
         thisleaplim = thisleapi + thisleapcnt;
         for (i = 0; i < typecnt; ++i)
             writetype[i] = thistimecnt == timecnt;
         if (thistimecnt == 0)
         {
             /*
              * No transition times fall in the current (32- or 64-bit) window.
              */
             if (typecnt != 0)
                 writetype[typecnt - 1] = true;
         }
         else
         {
             for (i = thistimei - 1; i < thistimelim; ++i)
                 if (i >= 0)
                     writetype[types[i]] = true;
 
             /*
              * For America/Godthab and Antarctica/Palmer
              */
             if (thistimei == 0)
                 writetype[0] = true;
         }
 #ifndef LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH
 
         /*
          * For some pre-2011 systems: if the last-to-be-written standard (or
          * daylight) type has an offset different from the most recently used
          * offset, append an (unused) copy of the most recently used type (to
          * help get global "altzone" and "timezone" variables set correctly).
          */
         {
             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 = 0; i < typecnt; ++i)
                 if (writetype[i])
                 {
                     if (isdsts[i])
                         hidst = i;
                     else
                         histd = i;
                 }
             if (hidst >= 0 && mrudst >= 0 && hidst != mrudst &&
                 gmtoffs[hidst] != gmtoffs[mrudst])
             {
                 isdsts[mrudst] = -1;
                 type = addtype(gmtoffs[mrudst],
                                &chars[abbrinds[mrudst]],
                                true,
                                ttisstds[mrudst],
                                ttisgmts[mrudst]);
                 isdsts[mrudst] = 1;
                 writetype[type] = true;
             }
             if (histd >= 0 && mrustd >= 0 && histd != mrustd &&
                 gmtoffs[histd] != gmtoffs[mrustd])
             {
                 isdsts[mrustd] = -1;
                 type = addtype(gmtoffs[mrustd],
                                &chars[abbrinds[mrustd]],
                                false,
                                ttisstds[mrustd],
                                ttisgmts[mrustd]);
                 isdsts[mrustd] = 0;
                 writetype[type] = true;
             }
         }
 #endif                          /* !defined
                                  * LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH */
         thistypecnt = 0;
         for (i = 0; i < typecnt; ++i)
             typemap[i] = writetype[i] ? thistypecnt++ : -1;
         for (i = 0; i < sizeof indmap / sizeof indmap[0]; ++i)
             indmap[i] = -1;
         thischarcnt = 0;
         for (i = 0; i < typecnt; ++i)
         {
             char       *thisabbr;
 
             if (!writetype[i])
                 continue;
             if (indmap[abbrinds[i]] >= 0)
                 continue;
             thisabbr = &chars[abbrinds[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[abbrinds[i]] = j;
         }
 #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(thistypecnt, tzh.tzh_ttisgmtcnt);
         convert(thistypecnt, tzh.tzh_ttisstdcnt);
         convert(thisleapcnt, tzh.tzh_leapcnt);
         convert(thistimecnt, tzh.tzh_timecnt);
         convert(thistypecnt, tzh.tzh_typecnt);
         convert(thischarcnt, tzh.tzh_charcnt);
         DO(tzh_magic);
         DO(tzh_version);
         DO(tzh_reserved);
         DO(tzh_ttisgmtcnt);
         DO(tzh_ttisstdcnt);
         DO(tzh_leapcnt);
         DO(tzh_timecnt);
         DO(tzh_typecnt);
         DO(tzh_charcnt);
 #undef DO
         for (i = thistimei; i < thistimelim; ++i)
             if (pass == 1)
 
                 /*
                  * Output an INT32_MIN "transition" if appropriate; see above.
                  */
                 puttzcode(((ats[i] < PG_INT32_MIN) ?
                            PG_INT32_MIN : ats[i]), fp);
             else
             {
                 puttzcode64(ats[i], fp);
 
                 /* Print current timezone abbreviations if requested */
                 if (print_abbrevs &&
                     (i == thistimelim - 1 || ats[i + 1] > print_cutoff))
                 {
                     unsigned char tm = typemap[types[i]];
                     char       *thisabbrev = &thischars[indmap[abbrinds[tm]]];
 
                     /* filter out assorted junk entries */
                     if (strcmp(thisabbrev, GRANDPARENTED) != 0 &&
                         strcmp(thisabbrev, "zzz") != 0)
                         fprintf(stdout, "%s\t" INT64_FORMAT "%s\n",
                                 thisabbrev,
                                 gmtoffs[tm],
                                 isdsts[tm] ? "\tD" : "");
                 }
             }
         for (i = thistimei; i < thistimelim; ++i)
         {
             unsigned char uc;
 
             uc = typemap[types[i]];
             fwrite(&uc, sizeof uc, 1, fp);
         }
         for (i = 0; i < typecnt; ++i)
             if (writetype[i])
             {
                 puttzcode(gmtoffs[i], fp);
                 putc(isdsts[i], fp);
                 putc((unsigned char) indmap[abbrinds[i]], fp);
             }
         if (thischarcnt != 0)
             fwrite(thischars, sizeof thischars[0],
                    thischarcnt, fp);
         for (i = thisleapi; i < thisleaplim; ++i)
         {
             zic_t       todo;
 
             if (roll[i])
             {
                 if (timecnt == 0 || trans[i] < ats[0])
                 {
                     j = 0;
                     while (isdsts[j])
                         if (++j >= typecnt)
                         {
                             j = 0;
                             break;
                         }
                 }
                 else
                 {
                     j = 1;
                     while (j < timecnt &&
                            trans[i] >= ats[j])
                         ++j;
                     j = types[j - 1];
                 }
                 todo = tadd(trans[i], -gmtoffs[j]);
             }
             else
                 todo = trans[i];
             if (pass == 1)
                 puttzcode(todo, fp);
             else
                 puttzcode64(todo, fp);
             puttzcode(corr[i], fp);
         }
         for (i = 0; i < typecnt; ++i)
             if (writetype[i])
                 putc(ttisstds[i], fp);
         for (i = 0; i < typecnt; ++i)
             if (writetype[i])
                 putc(ttisgmts[i], fp);
     }
     fprintf(fp, "\n%s\n", string);
     close_file(fp, directory, name);
     free(ats);
 }

◆ yearistype()

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

static

Definition at line 3248 of file zic.c.

References _, buf, emalloc(), error(), EXIT_FAILURE, free, INT64_FORMAT, INT_STRLEN_MAXIMUM, shellquote(), status(), WEXITSTATUS, and WIFEXITED.

Referenced by outzone().

 {
     char       *buf;
     char       *b;
     int         result;
 
     if (type == NULL || *type == '\0')
         return true;
     buf = emalloc(1 + 4 * strlen(yitcommand) + 2
                   + INT_STRLEN_MAXIMUM(zic_t) +2 + 4 * strlen(type) + 2);
     b = shellquote(buf, yitcommand);
     *b++ = ' ';
     b += sprintf(b, INT64_FORMAT, year);
     *b++ = ' ';
     b = shellquote(b, type);
     *b = '\0';
     result = system(buf);
     if (WIFEXITED(result))
     {
         int         status = WEXITSTATUS(result);
 
         if (status <= 1)
         {
             free(buf);
             return status == 0;
         }
     }
     error(_("Wild result from command execution"));
     fprintf(stderr, _("%s: command was '%s', result was %d\n"),
             progname, buf, result);
     exit(EXIT_FAILURE);
 }

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ BIG_BANG

◆ 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_STDOFF

◆ RF_TOD

◆ RULE_FIELDS

◆ TIME_T_BITS_IN_FILE

◆ YR_MAXIMUM

◆ YR_MINIMUM

◆ YR_ONLY

◆ ZF_FORMAT

◆ ZF_GMTOFF

◆ ZF_NAME

◆ ZF_RULE

◆ ZF_TILDAY

◆ ZF_TILMONTH

◆ ZF_TILTIME

◆ ZF_TILYEAR

◆ ZFC_FORMAT

◆ ZFC_GMTOFF

◆ ZFC_RULE

◆ ZFC_TILDAY

◆ ZFC_TILMONTH

◆ ZFC_TILTIME

◆ ZFC_TILYEAR

◆ 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

◆ anonymous enum

◆ anonymous enum

Function Documentation

◆ abbroffset()

◆ addtt()

◆ addtype()

◆ adjleap()