-/* $OpenBSD: zdump.c,v 1.9 2015/02/10 22:44:29 deraadt Exp $ */
+/* $OpenBSD: zdump.c,v 1.10 2015/04/23 05:26:33 deraadt Exp $ */
/*
** This file is in the public domain, so clarified as of
** 2009-05-17 by Arthur David Olson.
** You can use this code to help in verifying other implementations.
*/
-#include <ctype.h> /* for isalpha et al. */
-#include <float.h> /* for FLT_MAX and DBL_MAX */
-#include <stdio.h> /* for stdout, stderr, perror */
-#include <string.h> /* for strlcpy */
-#include <stdlib.h> /* for exit, malloc, atoi */
-#include <time.h> /* for struct tm */
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
-#ifndef ZDUMP_LO_YEAR
#define ZDUMP_LO_YEAR (-500)
-#endif /* !defined ZDUMP_LO_YEAR */
-
-#ifndef ZDUMP_HI_YEAR
#define ZDUMP_HI_YEAR 2500
-#endif /* !defined ZDUMP_HI_YEAR */
-#ifndef MAX_STRING_LENGTH
#define MAX_STRING_LENGTH 1024
-#endif /* !defined MAX_STRING_LENGTH */
-#ifndef TRUE
#define TRUE 1
-#endif /* !defined TRUE */
-
-#ifndef FALSE
#define FALSE 0
-#endif /* !defined FALSE */
-#ifndef SECSPERMIN
#define SECSPERMIN 60
-#endif /* !defined SECSPERMIN */
-
-#ifndef MINSPERHOUR
#define MINSPERHOUR 60
-#endif /* !defined MINSPERHOUR */
-
-#ifndef SECSPERHOUR
#define SECSPERHOUR (SECSPERMIN * MINSPERHOUR)
-#endif /* !defined SECSPERHOUR */
-
-#ifndef HOURSPERDAY
#define HOURSPERDAY 24
-#endif /* !defined HOURSPERDAY */
-
-#ifndef EPOCH_YEAR
#define EPOCH_YEAR 1970
-#endif /* !defined EPOCH_YEAR */
-
-#ifndef TM_YEAR_BASE
#define TM_YEAR_BASE 1900
-#endif /* !defined TM_YEAR_BASE */
-
-#ifndef DAYSPERNYEAR
#define DAYSPERNYEAR 365
-#endif /* !defined DAYSPERNYEAR */
-#ifndef isleap
+#define SECSPERDAY ((long) SECSPERHOUR * HOURSPERDAY)
+#define SECSPERNYEAR (SECSPERDAY * DAYSPERNYEAR)
+#define SECSPERLYEAR (SECSPERNYEAR + SECSPERDAY)
+
#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
-#endif /* !defined isleap */
#ifndef isleap_sum
/*
#define isleap_sum(a, b) isleap((a) % 400 + (b) % 400)
#endif /* !defined isleap_sum */
-#define SECSPERDAY ((long) SECSPERHOUR * HOURSPERDAY)
-#define SECSPERNYEAR (SECSPERDAY * DAYSPERNYEAR)
-#define SECSPERLYEAR (SECSPERNYEAR + SECSPERDAY)
-
-#define _(msgid) msgid
-
-#ifndef TZ_DOMAIN
-#define TZ_DOMAIN "tz"
-#endif /* !defined TZ_DOMAIN */
-
-extern char ** environ;
-extern int getopt(int argc, char * const argv[],
- const char * options);
-extern char * optarg;
-extern int optind;
-extern char * tzname[2];
-
-static time_t absolute_min_time;
-static time_t absolute_max_time;
-static size_t longest;
-static char * progname;
-static int warned;
-
-static char * abbr(struct tm * tmp);
-static void abbrok(const char * abbrp, const char * zone);
-static long delta(struct tm * newp, struct tm * oldp);
-static void dumptime(const struct tm * tmp);
-static time_t hunt(char * name, time_t lot, time_t hit);
-static void setabsolutes(void);
-static void show(char * zone, time_t t, int v);
-static const char * tformat(void);
-static time_t yeartot(long y);
-
-#ifndef TYPECHECK
-#define my_localtime localtime
-#else /* !defined TYPECHECK */
-static struct tm *
-my_localtime(tp)
-time_t * tp;
-{
- struct tm * tmp;
-
- tmp = localtime(tp);
- if (tp != NULL && tmp != NULL) {
- struct tm tm;
- time_t t;
-
- tm = *tmp;
- t = mktime(&tm);
- if (t - *tp >= 1 || *tp - t >= 1) {
- fflush(stdout);
- fprintf(stderr, "\n%s: ", progname);
- fprintf(stderr, tformat(), *tp);
- fprintf(stderr, " ->");
- fprintf(stderr, " year=%d", tmp->tm_year);
- fprintf(stderr, " mon=%d", tmp->tm_mon);
- fprintf(stderr, " mday=%d", tmp->tm_mday);
- fprintf(stderr, " hour=%d", tmp->tm_hour);
- fprintf(stderr, " min=%d", tmp->tm_min);
- fprintf(stderr, " sec=%d", tmp->tm_sec);
- fprintf(stderr, " isdst=%d", tmp->tm_isdst);
- fprintf(stderr, " -> ");
- fprintf(stderr, tformat(), t);
- fprintf(stderr, "\n");
- }
- }
- return tmp;
-}
-#endif /* !defined TYPECHECK */
+extern char **environ;
+extern char *tzname[2];
+extern char *__progname;
+
+time_t absolute_min_time;
+time_t absolute_max_time;
+size_t longest;
+int warned;
+
+static char *abbr(struct tm *tmp);
+static void abbrok(const char *abbrp, const char *zone);
+static long delta(struct tm *newp, struct tm *oldp);
+static void dumptime(const struct tm *tmp);
+static time_t hunt(char *name, time_t lot, time_t hit);
+static void setabsolutes(void);
+static void show(char *zone, time_t t, int v);
+static const char *tformat(void);
+static time_t yeartot(long y);
+static void usage(void);
static void
-abbrok(abbrp, zone)
-const char * const abbrp;
-const char * const zone;
+abbrok(const char * const abbrp, const char * const zone)
{
- const char * cp;
- char * wp;
+ const char *cp;
+ char *wp;
if (warned)
return;
while (isascii((unsigned char) *cp) && isalpha((unsigned char) *cp))
++cp;
if (cp - abbrp == 0)
- wp = _("lacks alphabetic at start");
+ wp = "lacks alphabetic at start";
else if (cp - abbrp < 3)
- wp = _("has fewer than 3 alphabetics");
+ wp = "has fewer than 3 alphabetics";
else if (cp - abbrp > 6)
- wp = _("has more than 6 alphabetics");
+ wp = "has more than 6 alphabetics";
if (wp == NULL && (*cp == '+' || *cp == '-')) {
++cp;
if (isascii((unsigned char) *cp) &&
- isdigit((unsigned char) *cp))
- if (*cp++ == '1' && *cp >= '0' && *cp <= '4')
- ++cp;
+ isdigit((unsigned char) *cp))
+ if (*cp++ == '1' && *cp >= '0' && *cp <= '4')
+ ++cp;
if (*cp != '\0')
- wp = _("differs from POSIX standard");
+ wp = "differs from POSIX standard";
}
if (wp == NULL)
return;
fflush(stdout);
- fprintf(stderr, _("%s: warning: zone \"%s\" abbreviation \"%s\" %s\n"),
- progname, zone, abbrp, wp);
+ fprintf(stderr, "%s: warning: zone \"%s\" abbreviation \"%s\" %s\n",
+ __progname, zone, abbrp, wp);
warned = TRUE;
}
static void
usage(void)
{
- fprintf(stderr, _("usage: %s [-v] [-c [loyear,]hiyear] zonename ...\n"), progname);
+ fprintf(stderr, "usage: %s [-v] [-c [loyear,]hiyear] zonename ...\n",
+ __progname);
exit(EXIT_FAILURE);
}
int
-main(argc, argv)
-int argc;
-char * argv[];
+main(int argc, char *argv[])
{
- int i;
- int c;
- int vflag;
- char * cutarg;
+ int i, c, vflag = 0;
+ char *cutarg = NULL;
long cutloyear = ZDUMP_LO_YEAR;
long cuthiyear = ZDUMP_HI_YEAR;
- time_t cutlotime;
- time_t cuthitime;
- char ** fakeenv;
- time_t now;
- time_t t;
- time_t newt;
- struct tm tm;
- struct tm newtm;
- struct tm * tmp;
- struct tm * newtmp;
-
- cutlotime = 0;
- cuthitime = 0;
- progname = argv[0];
- vflag = 0;
- cutarg = NULL;
- while ((c = getopt(argc, argv, "c:v")) == 'c' || c == 'v')
- if (c == 'v')
+ time_t cutlotime = 0, cuthitime = 0;
+ time_t now, t, newt;
+ struct tm tm, newtm, *tmp, *newtmp;
+ char **fakeenv;
+
+ while ((c = getopt(argc, argv, "c:v")) == 'c' || c == 'v') {
+ switch (c) {
+ case 'v':
vflag = 1;
- else cutarg = optarg;
- if ((c != EOF && c != -1) ||
- (optind == argc - 1 && strcmp(argv[optind], "=") == 0)) {
+ break;
+ case 'c':
+ cutarg = optarg;
+ break;
+ default:
usage();
+ break;
+ }
+ }
+ if (c != -1 ||
+ (optind == argc - 1 && strcmp(argv[optind], "=") == 0)) {
+ usage();
}
if (vflag) {
if (cutarg != NULL) {
- long lo;
- long hi;
+ long lo, hi;
char dummy;
if (sscanf(cutarg, "%ld%c", &hi, &dummy) == 1) {
cuthiyear = hi;
} else if (sscanf(cutarg, "%ld,%ld%c",
- &lo, &hi, &dummy) == 2) {
- cutloyear = lo;
- cuthiyear = hi;
+ &lo, &hi, &dummy) == 2) {
+ cutloyear = lo;
+ cuthiyear = hi;
} else {
- fprintf(stderr, _("%s: wild -c argument %s\n"),
- progname, cutarg);
+ fprintf(stderr, "%s: wild -c argument %s\n",
+ __progname, cutarg);
exit(EXIT_FAILURE);
}
}
for (i = optind; i < argc; ++i)
if (strlen(argv[i]) > longest)
longest = strlen(argv[i]);
+
{
- int from;
- int to;
+ int from, to;
for (i = 0; environ[i] != NULL; ++i)
continue;
fakeenv = reallocarray(NULL, i + 2, sizeof *fakeenv);
if (fakeenv == NULL ||
- (fakeenv[0] = malloc(longest + 4)) == NULL) {
- perror(progname);
- exit(EXIT_FAILURE);
+ (fakeenv[0] = malloc(longest + 4)) == NULL) {
+ perror(__progname);
+ exit(EXIT_FAILURE);
}
to = 0;
strlcpy(fakeenv[to++], "TZ=", longest + 4);
environ = fakeenv;
}
for (i = optind; i < argc; ++i) {
- static char buf[MAX_STRING_LENGTH];
+ char buf[MAX_STRING_LENGTH];
strlcpy(&fakeenv[0][3], argv[i], longest + 1);
if (!vflag) {
show(argv[i], t, TRUE);
if (t < cutlotime)
t = cutlotime;
- tmp = my_localtime(&t);
+ tmp = localtime(&t);
if (tmp != NULL) {
tm = *tmp;
strlcpy(buf, abbr(&tm), sizeof buf);
if (newtmp != NULL)
newtm = *newtmp;
if ((tmp == NULL || newtmp == NULL) ? (tmp != newtmp) :
- (delta(&newtm, &tm) != (newt - t) ||
- newtm.tm_isdst != tm.tm_isdst ||
- strcmp(abbr(&newtm), buf) != 0)) {
- newt = hunt(argv[i], t, newt);
- newtmp = localtime(&newt);
- if (newtmp != NULL) {
- newtm = *newtmp;
- strlcpy(buf, abbr(&newtm),
- sizeof buf);
- }
+ (delta(&newtm, &tm) != (newt - t) ||
+ newtm.tm_isdst != tm.tm_isdst ||
+ strcmp(abbr(&newtm), buf) != 0)) {
+ newt = hunt(argv[i], t, newt);
+ newtmp = localtime(&newt);
+ if (newtmp != NULL) {
+ newtm = *newtmp;
+ strlcpy(buf, abbr(&newtm), sizeof buf);
+ }
}
t = newt;
tm = newtm;
show(argv[i], t, TRUE);
}
if (fflush(stdout) || ferror(stdout)) {
- fprintf(stderr, "%s: ", progname);
- perror(_("Error writing to standard output"));
+ fprintf(stderr, "%s: ", __progname);
+ perror("Error writing to standard output");
exit(EXIT_FAILURE);
}
return 0;
static void
setabsolutes(void)
{
- /*
- ** time_t is signed. Assume overflow wraps around.
- */
- time_t t = 0;
- time_t t1 = 1;
+ time_t t = 0, t1 = 1;
while (t < t1) {
t = t1;
}
static time_t
-yeartot(y)
-const long y;
+yeartot(const long y)
{
- long myy;
- long seconds;
- time_t t;
+ long myy = EPOCH_YEAR, seconds;
+ time_t t = 0;
- myy = EPOCH_YEAR;
- t = 0;
while (myy != y) {
if (myy < y) {
seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
{
time_t t;
long diff;
- struct tm lotm;
- struct tm * lotmp;
- struct tm tm;
- struct tm * tmp;
+ struct tm lotm, *lotmp;
+ struct tm tm, *tmp;
char loab[MAX_STRING_LENGTH];
- lotmp = my_localtime(&lot);
+ lotmp = localtime(&lot);
if (lotmp != NULL) {
lotm = *lotmp;
strlcpy(loab, abbr(&lotm), sizeof loab);
++t;
else if (t >= hit)
--t;
- tmp = my_localtime(&t);
+ tmp = localtime(&t);
if (tmp != NULL)
tm = *tmp;
if ((lotmp == NULL || tmp == NULL) ? (lotmp == tmp) :
- (delta(&tm, &lotm) == (t - lot) &&
- tm.tm_isdst == lotm.tm_isdst &&
- strcmp(abbr(&tm), loab) == 0)) {
- lot = t;
- lotm = tm;
- lotmp = tmp;
- } else hit = t;
+ (delta(&tm, &lotm) == (t - lot) &&
+ tm.tm_isdst == lotm.tm_isdst &&
+ strcmp(abbr(&tm), loab) == 0)) {
+ lot = t;
+ lotm = tm;
+ lotmp = tmp;
+ } else
+ hit = t;
}
show(name, lot, TRUE);
show(name, hit, TRUE);
*/
static long
-delta(newp, oldp)
-struct tm * newp;
-struct tm * oldp;
+delta(struct tm *newp, struct tm *oldp)
{
long result;
int tmy;
static void
show(char *zone, time_t t, int v)
{
- struct tm * tmp;
+ struct tm *tmp;
printf("%-*s ", (int) longest, zone);
if (v) {
}
printf(" = ");
}
- tmp = my_localtime(&t);
+ tmp = localtime(&t);
dumptime(tmp);
if (tmp != NULL) {
if (*abbr(tmp) != '\0')
}
static char *
-abbr(tmp)
-struct tm * tmp;
+abbr(struct tm *tmp)
{
- char * result;
+ char *result;
static char nada;
if (tmp->tm_isdst != 0 && tmp->tm_isdst != 1)
}
static void
-dumptime(timeptr)
-const struct tm * timeptr;
+dumptime(const struct tm *timeptr)
{
- static const char wday_name[][3] = {
+ static const char wday_name[][3] = {
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
- static const char mon_name[][3] = {
+ static const char mon_name[][3] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
- const char * wn;
- const char * mn;
- int lead;
- int trail;
+ const char *wn, *mn;
+ int lead, trail;
if (timeptr == NULL) {
printf("NULL");
** with other (perhaps experimental) versions, paranoia is in order.
*/
if (timeptr->tm_wday < 0 || timeptr->tm_wday >=
- (int) (sizeof wday_name / sizeof wday_name[0]))
- wn = "???";
- else wn = wday_name[timeptr->tm_wday];
+ (int) (sizeof wday_name / sizeof wday_name[0]))
+ wn = "???";
+ else
+ wn = wday_name[timeptr->tm_wday];
if (timeptr->tm_mon < 0 || timeptr->tm_mon >=
- (int) (sizeof mon_name / sizeof mon_name[0]))
- mn = "???";
- else mn = mon_name[timeptr->tm_mon];
+ (int) (sizeof mon_name / sizeof mon_name[0]))
+ mn = "???";
+ else
+ mn = mon_name[timeptr->tm_mon];
printf("%.3s %.3s%3d %.2d:%.2d:%.2d ",
- wn, mn,
- timeptr->tm_mday, timeptr->tm_hour,
- timeptr->tm_min, timeptr->tm_sec);
+ wn, mn,
+ timeptr->tm_mday, timeptr->tm_hour,
+ timeptr->tm_min, timeptr->tm_sec);
#define DIVISOR 10
trail = timeptr->tm_year % DIVISOR + TM_YEAR_BASE % DIVISOR;
lead = timeptr->tm_year / DIVISOR + TM_YEAR_BASE / DIVISOR +
-/* $OpenBSD: zic.c,v 1.19 2015/03/13 17:23:37 deraadt Exp $ */
+/* $OpenBSD: zic.c,v 1.20 2015/04/23 05:26:33 deraadt Exp $ */
/*
** This file is in the public domain, so clarified as of
** 2006-07-17 by Arthur David Olson.
*/
+#include <sys/types.h>
+#include <sys/wait.h>
#include <sys/stat.h>
#include <ctype.h>
#include <err.h>
+#include <errno.h>
+#include <limits.h>
#include <locale.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <time.h>
#include "tzfile.h"
-#include "private.h"
+
+#define TRUE 1
+#define FALSE 0
+
+#define TYPE_SIGNED(type) (((type) -1) < 0)
+
+#define YEARSPERREPEAT 400 /* years before a Gregorian repeat */
+
+#define GRANDPARENTED "Local time zone must be set--see zic manual page"
#define ZIC_VERSION '2'
#define end(cp, n) (memchr((cp), '\0', (n)))
struct rule {
- const char * r_filename;
+ const char *r_filename;
int r_linenum;
- const char * r_name;
+ const char *r_name;
int r_loyear; /* for example, 1986 */
int r_hiyear; /* for example, 1986 */
- const char * r_yrtype;
+ const char *r_yrtype;
int r_lowasnum;
int r_hiwasnum;
int r_todisgmt; /* above is GMT if TRUE */
/* or local time if FALSE */
long r_stdoff; /* offset from standard time */
- const char * r_abbrvar; /* variable part of abbreviation */
+ const char *r_abbrvar; /* variable part of abbreviation */
int r_todo; /* a rule to do (used in outzone) */
zic_t r_temp; /* used in outzone */
#define DC_DOWLEQ 2 /* 1..31 */ /* 0..6 (Sun..Sat) */
struct zone {
- const char * z_filename;
+ const char *z_filename;
int z_linenum;
- const char * z_name;
+ const char *z_name;
long z_gmtoff;
- const char * z_rule;
- const char * z_format;
+ const char *z_rule;
+ const char *z_format;
long z_stdoff;
- struct rule * z_rules;
+ struct rule *z_rules;
int z_nrules;
struct rule z_untilrule;
};
static void addtt(zic_t starttime, int type);
-static int addtype(long gmtoff, const char * abbr, int isdst,
- int ttisstd, int ttisgmt);
+static int addtype(long gmtoff, const char *abbr, int isdst,
+ int ttisstd, int ttisgmt);
static void leapadd(zic_t t, int positive, int rolling, int count);
static void adjleap(void);
static void associate(void);
-static void convert(long val, char * buf);
-static void convert64(zic_t val, char * buf);
-static void dolink(const char * fromfield, const char * tofield);
-static void doabbr(char * abbr, size_t size, const char * format,
- const char * letters, int isdst, int doquotes);
-static void eat(const char * name, int num);
-static void eats(const char * name, int num,
- const char * rname, int rnum);
+static void convert(long val, char *buf);
+static void convert64(zic_t val, char *buf);
+static void dolink(const char *fromfield, const char *tofield);
+static void doabbr(char *abbr, size_t size, const char *format,
+ const char *letters, int isdst, int doquotes);
+static void eat(const char *name, int num);
+static void eats(const char *name, int num, const char *rname, int rnum);
static long eitol(int i);
-static void error(const char * message);
-static char ** getfields(char * buf);
-static long gethms(const char * string, const char * errstrng,
- int signable);
-static void infile(const char * filename);
-static void inleap(char ** fields, int nfields);
-static void inlink(char ** fields, int nfields);
-static void inrule(char ** fields, int nfields);
-static int inzcont(char ** fields, int nfields);
-static int inzone(char ** fields, int nfields);
-static int inzsub(char ** fields, int nfields, int iscont);
+static void error(const char *message);
+static char **getfields(char *buf);
+static long gethms(const char *string, const char *errstrng, int signable);
+static void infile(const char *filename);
+static void inleap(char **fields, int nfields);
+static void inlink(char **fields, int nfields);
+static void inrule(char **fields, int nfields);
+static int inzcont(char **fields, int nfields);
+static int inzone(char **fields, int nfields);
+static int inzsub(char **fields, int nfields, int iscont);
static int is32(zic_t x);
-static int itsabbr(const char * abbr, const char * word);
-static int itsdir(const char * name);
-static int mkdirs(char * filename);
-static void newabbr(const char * abbr);
+static int itsabbr(const char *abbr, const char *word);
+static int itsdir(const char *name);
+static int mkdirs(char *filename);
+static void newabbr(const char *abbr);
static long oadd(long t1, long t2);
-static void outzone(const struct zone * zp, int ntzones);
-static void puttzcode(long code, FILE * fp);
-static void puttzcode64(zic_t code, FILE * fp);
-static int rcomp(const void * leftp, const void * rightp);
-static zic_t rpytime(const struct rule * rp, int 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 int stringoffset(char * result, size_t size, long offset);
-static int stringrule(char * result, size_t size, const struct rule * rp,
- long dstoff, long gmtoff);
-static void stringzone(char * result, size_t size,
- const struct zone * zp, int ntzones);
+static void outzone(const struct zone *zp, int ntzones);
+static void puttzcode(long code, FILE *fp);
+static void puttzcode64(zic_t code, FILE *fp);
+static int rcomp(const void *leftp, const void *rightp);
+static zic_t rpytime(const struct rule *rp, int 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 int stringoffset(char *result, size_t size, long offset);
+static int stringrule(char *result, size_t size, const struct rule *rp,
+ long dstoff, long gmtoff);
+static void stringzone(char *result, size_t size,
+ const struct zone *zp, int ntzones);
static void setboundaries(void);
static zic_t tadd(zic_t t1, long t2);
static void usage(void);
-static void writezone(const char * name, const char * string);
-static int yearistype(int year, const char * type);
+static void writezone(const char *name, const char *string);
+static int yearistype(int year, const char *type);
+
+extern char *__progname;
static int charcnt;
static int errors;
-static const char * filename;
+static const char *filename;
static int leapcnt;
static int leapseen;
static int leapminyear;
static zic_t min_time;
static int min_year;
static int noise;
-static const char * rfilename;
+static const char *rfilename;
static int rlinenum;
-static const char * progname;
static int timecnt;
static int typecnt;
#define YR_MAXIMUM 1
#define YR_ONLY 2
-static struct rule * rules;
+static struct rule *rules;
static int nrules; /* number of rules */
-static struct zone * zones;
+static struct zone *zones;
static int nzones; /* number of zones */
struct link {
- const char * l_filename;
+ const char *l_filename;
int l_linenum;
- const char * l_from;
- const char * l_to;
+ const char *l_from;
+ const char *l_to;
};
-static struct link * links;
+static struct link *links;
static int nlinks;
struct lookup {
- const char * l_word;
+ const char *l_word;
const int l_value;
};
-static struct lookup const * byword(const char * string,
- const struct lookup * lp);
+static struct lookup const *byword(const char *string, const struct lookup *lp);
static struct lookup const line_codes[] = {
{ "Rule", LC_RULE },
zic_t at;
unsigned char type;
} attypes[TZ_MAX_TIMES];
+
static long gmtoffs[TZ_MAX_TYPES];
static char isdsts[TZ_MAX_TYPES];
static unsigned char abbrinds[TZ_MAX_TYPES];
static void *
memcheck(void *ptr)
{
- if (ptr == NULL) {
+ if (ptr == NULL)
err(1, "Memory exhausted");
- }
return ptr;
}
** zic ... 2>&1 | error -t "*" -v
** on BSD systems.
*/
- fprintf(stderr, _("\"%s\", line %d: %s"),
+ fprintf(stderr, "\"%s\", line %d: %s",
filename, linenum, string);
if (rfilename != NULL)
- fprintf(stderr, _(" (rule from \"%s\", line %d)"),
+ fprintf(stderr, " (rule from \"%s\", line %d)",
rfilename, rlinenum);
fprintf(stderr, "\n");
++errors;
static void
warning(const char *string)
{
- char * cp;
+ char *cp;
- cp = ecpyalloc(_("warning: "));
+ cp = ecpyalloc("warning: ");
cp = ecatalloc(cp, string);
error(cp);
free(cp);
static const char *
scheck(const char *string, const char *format)
{
- char * fbuf;
- const char * fp;
- char * tp;
+ const char *fp, *result;
+ char *fbuf, *tp, dummy;
int c;
- const char * result;
- char dummy;
result = "";
if (string == NULL || format == NULL)
if (*fp == 'l' || *fp == 'h')
*tp++ = *fp++;
else if (*fp == '[')
- do *tp++ = *fp++;
- while (*fp != '\0' && *fp != ']');
+ do {
+ *tp++ = *fp++;
+ } while (*fp != '\0' && *fp != ']');
if ((*tp++ = *fp++) == '\0')
break;
}
static void
usage(void)
{
- fprintf(stderr, _("usage: %s [-v] [-d directory] [-L leapsecondfilename] [-l timezone]\n\t[-p timezone] [-y command] [filename ...]\n"),
- progname);
+ fprintf(stderr,
+ "usage: %s [-v] [-d directory] [-L leapsecondfilename] [-l timezone]\n"
+ "\t\t[-p timezone] [-y command] [filename ...]\n",
+ __progname);
exit(EXIT_FAILURE);
}
-static const char * psxrules;
-static const char * lcltime;
-static const char * directory;
-static const char * leapsec;
-static const char * yitcommand;
+static const char *psxrules;
+static const char *lcltime;
+static const char *directory;
+static const char *leapsec;
+static const char *yitcommand;
int
main(int argc, char **argv)
{
- int i;
- int j;
- int c;
+ int i, j, c;
umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
- progname = argv[0];
while ((c = getopt(argc, argv, "d:l:p:L:vy:")) != -1)
switch (c) {
default:
case 'd':
if (directory == NULL)
directory = optarg;
- else {
+ else
errx(1, "More than one -d option specified");
- }
break;
case 'l':
if (lcltime == NULL)
lcltime = optarg;
- else {
+ else
errx(1, "More than one -l option specified");
- }
break;
case 'p':
if (psxrules == NULL)
psxrules = optarg;
- else {
+ else
errx(1, "More than one -p option specified");
- }
break;
case 'y':
if (yitcommand == NULL)
yitcommand = optarg;
- else {
+ else
errx(1, "More than one -y option specified");
- }
break;
case 'L':
if (leapsec == NULL)
leapsec = optarg;
- else {
+ else
errx(1, "More than one -L option specified");
- }
break;
case 'v':
noise = TRUE;
for (j = 0; j < nlinks; ++j)
if (strcmp(links[i].l_to,
links[j].l_from) == 0)
- warning(_("link to link"));
+ warning("link to link");
}
if (lcltime != NULL) {
eat("command line", 1);
static void
dolink(const char *fromfield, const char *tofield)
{
- char * fromname;
- char * toname;
+ char *fromname, *toname;
if (fromfield[0] == '/')
fromname = ecpyalloc(fromfield);
result = link(fromname, toname);
if (result != 0 && errno == EXDEV)
result = symlink(fromname, toname);
- if (result != 0) {
+ if (result != 0)
err(1, "Can't link from %s to %s", fromname, toname);
- }
}
free(fromname);
free(toname);
static int
itsdir(const char *name)
{
- char * myname;
+ char *myname;
int accres;
myname = ecpyalloc(name);
static void
associate(void)
{
- struct zone * zp;
- struct rule * rp;
- int base, out;
- int i, j;
+ struct zone *zp;
+ struct rule *rp;
+ int base, out, i, j;
if (nrules != 0) {
qsort(rules, nrules, sizeof *rules, rcomp);
rules[i + 1].r_filename) == 0)
continue;
eat(rules[i].r_filename, rules[i].r_linenum);
- warning(_("same rule name in multiple files"));
+ 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"));
+ 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)
** Maybe we have a local standard time offset.
*/
eat(zp->z_filename, zp->z_linenum);
- zp->z_stdoff = gethms(zp->z_rule, _("unruly zone"),
+ zp->z_stdoff = gethms(zp->z_rule, "unruly zone",
TRUE);
/*
** Note, though, that if there's no rule,
** a '%s' in the format is a bad thing.
*/
if (strchr(zp->z_format, '%') != 0)
- error(_("%s in ruleless zone"));
+ error("%s in ruleless zone");
}
}
if (errors)
static void
infile(const char *name)
{
- FILE * fp;
- char ** fields;
- char * cp;
- const struct lookup * lp;
- int nfields;
- int wantcont;
- int num;
- char buf[BUFSIZ];
+ FILE *fp;
+ char **fields, *cp;
+ const struct lookup *lp;
+ int nfields, wantcont, num;
+ char buf[BUFSIZ];
if (strcmp(name, "-") == 0) {
- name = _("standard input");
+ name = "standard input";
fp = stdin;
- } else if ((fp = fopen(name, "r")) == NULL) {
+ } else if ((fp = fopen(name, "r")) == NULL)
err(1, "Can't open %s", name);
- }
wantcont = FALSE;
for (num = 1; ; ++num) {
eat(name, num);
break;
cp = strchr(buf, '\n');
if (cp == NULL) {
- error(_("line too long"));
+ error("line too long");
exit(EXIT_FAILURE);
}
*cp = '\0';
} else {
lp = byword(fields[0], line_codes);
if (lp == NULL)
- error(_("input line of unknown type"));
+ error("input line of unknown type");
else switch ((int) (lp->l_value)) {
case LC_RULE:
inrule(fields, nfields);
case LC_LEAP:
if (name != leapsec)
fprintf(stderr,
- _("%s: Leap line in non leap seconds file %s\n"),
- progname, name);
+ "%s: Leap line in non leap seconds file %s\n",
+ __progname, name);
/* no exit? */
else
inleap(fields, nfields);
}
free(fields);
}
- if (ferror(fp)) {
+ if (ferror(fp))
errx(1, "Error reading %s", filename);
- }
- if (fp != stdin && fclose(fp)) {
+ if (fp != stdin && fclose(fp))
err(1, "Error closing %s", filename);
- }
if (wantcont)
- error(_("expected continuation line not found"));
+ error("expected continuation line not found");
}
/*
else if (*string == '-') {
sign = -1;
++string;
- } else sign = 1;
+ } else
+ sign = 1;
if (sscanf(string, scheck(string, "%ld"), &hh) == 1)
mm = ss = 0;
else if (sscanf(string, scheck(string, "%ld:%d"), &hh, &mm) == 2)
ss = 0;
else if (sscanf(string, scheck(string, "%ld:%d:%d"),
- &hh, &mm, &ss) != 3) {
- error(errstring);
- return 0;
+ &hh, &mm, &ss) != 3) {
+ error(errstring);
+ return 0;
}
if (hh < 0 ||
- mm < 0 || mm >= MINSPERHOUR ||
- ss < 0 || ss > SECSPERMIN) {
- error(errstring);
- return 0;
+ mm < 0 || mm >= MINSPERHOUR ||
+ ss < 0 || ss > SECSPERMIN) {
+ error(errstring);
+ return 0;
}
if (LONG_MAX / SECSPERHOUR < hh) {
- error(_("time overflow"));
+ error("time overflow");
return 0;
}
return oadd(eitol(sign) * hh * eitol(SECSPERHOUR),
- eitol(sign) * (eitol(mm) * eitol(SECSPERMIN) + eitol(ss)));
+ eitol(sign) * (eitol(mm) * eitol(SECSPERMIN) + eitol(ss)));
}
static void
static struct rule r;
if (nfields != RULE_FIELDS) {
- error(_("wrong number of fields on Rule line"));
+ error("wrong number of fields on Rule line");
return;
}
if (*fields[RF_NAME] == '\0') {
- error(_("nameless rule"));
+ error("nameless rule");
return;
}
r.r_filename = filename;
r.r_linenum = linenum;
- r.r_stdoff = gethms(fields[RF_STDOFF], _("invalid saved time"), TRUE);
+ r.r_stdoff = gethms(fields[RF_STDOFF], "invalid saved time", TRUE);
rulesub(&r, fields[RF_LOYEAR], fields[RF_HIYEAR], fields[RF_COMMAND],
fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
r.r_name = ecpyalloc(fields[RF_NAME]);
inzone(char **fields, int nfields)
{
int i;
- static char * buf;
+ static char *buf;
size_t len;
if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS) {
- error(_("wrong number of fields on Zone line"));
+ error("wrong number of fields on Zone line");
return FALSE;
}
if (strcmp(fields[ZF_NAME], TZDEFAULT) == 0 && lcltime != NULL) {
len = 132 + strlen(TZDEFAULT);
buf = erealloc(buf, len);
- snprintf(buf, len, _("\"Zone %s\" line and -l option are mutually exclusive"),
- TZDEFAULT);
+ snprintf(buf, len,
+ "\"Zone %s\" line and -l option are mutually exclusive",
+ TZDEFAULT);
error(buf);
return FALSE;
}
if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL) {
len = 132 + strlen(TZDEFRULES);
buf = erealloc(buf, len);
- snprintf(buf, len, _("\"Zone %s\" line and -p option are mutually exclusive"),
- TZDEFRULES);
+ snprintf(buf, len,
+ "\"Zone %s\" line and -p option are mutually exclusive",
+ TZDEFRULES);
error(buf);
return FALSE;
}
for (i = 0; i < nzones; ++i)
if (zones[i].z_name != NULL &&
- strcmp(zones[i].z_name, fields[ZF_NAME]) == 0) {
- len = 132 + strlen(fields[ZF_NAME]) +
- strlen(zones[i].z_filename);
- buf = erealloc(buf, len);
- snprintf(buf, len,
- _("duplicate zone name %s (file \"%s\", line %d)"),
- fields[ZF_NAME],
- zones[i].z_filename,
- zones[i].z_linenum);
- error(buf);
- return FALSE;
+ strcmp(zones[i].z_name, fields[ZF_NAME]) == 0) {
+ len = 132 + strlen(fields[ZF_NAME]) +
+ strlen(zones[i].z_filename);
+ buf = erealloc(buf, len);
+ snprintf(buf, len,
+ "duplicate zone name %s (file \"%s\", line %d)",
+ fields[ZF_NAME],
+ zones[i].z_filename,
+ zones[i].z_linenum);
+ error(buf);
+ return FALSE;
}
return inzsub(fields, nfields, FALSE);
}
inzcont(char **fields, int nfields)
{
if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS) {
- error(_("wrong number of fields on Zone continuation line"));
+ error("wrong number of fields on Zone continuation line");
return FALSE;
}
return inzsub(fields, nfields, TRUE);
static int
inzsub(char **fields, int nfields, int iscont)
{
- char * cp;
+ char *cp;
static struct zone z;
int i_gmtoff, i_rule, i_format;
int i_untilyear, i_untilmonth;
}
z.z_filename = filename;
z.z_linenum = linenum;
- z.z_gmtoff = gethms(fields[i_gmtoff], _("invalid UTC offset"), TRUE);
+ z.z_gmtoff = gethms(fields[i_gmtoff], "invalid UTC offset", TRUE);
if ((cp = strchr(fields[i_format], '%')) != 0) {
if (*++cp != 's' || strchr(cp, '%') != 0) {
- error(_("invalid abbreviation format"));
+ error("invalid abbreviation format");
return FALSE;
}
}
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;
+ 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 = ereallocarray(zones, nzones + 1, sizeof *zones);
static void
inleap(char **fields, int nfields)
{
- const char * cp;
- const struct lookup * lp;
+ const char *cp;
+ const struct lookup *lp;
int i, j;
- int year, month, day;
- long dayoff, tod;
- zic_t t;
+ int year, month, day;
+ long dayoff, tod;
+ zic_t t;
if (nfields != LEAP_FIELDS) {
- error(_("wrong number of fields on Leap line"));
+ error("wrong number of fields on Leap line");
return;
}
dayoff = 0;
/*
** Leapin' Lizards!
*/
- error(_("invalid leaping year"));
+ error("invalid leaping year");
return;
}
if (!leapseen || leapmaxyear < year)
dayoff = oadd(dayoff, eitol(i));
}
if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL) {
- error(_("invalid month name"));
+ error("invalid month name");
return;
}
month = lp->l_value;
}
cp = fields[LP_DAY];
if (sscanf(cp, scheck(cp, "%d"), &day) != 1 ||
- day <= 0 || day > len_months[isleap(year)][month]) {
- error(_("invalid day of month"));
- return;
+ day <= 0 || day > len_months[isleap(year)][month]) {
+ error("invalid day of month");
+ return;
}
dayoff = oadd(dayoff, eitol(day - 1));
if (dayoff < 0 && !TYPE_SIGNED(zic_t)) {
- error(_("time before zero"));
+ error("time before zero");
return;
}
if (dayoff < min_time / SECSPERDAY) {
- error(_("time too small"));
+ error("time too small");
return;
}
if (dayoff > max_time / SECSPERDAY) {
- error(_("time too large"));
+ error("time too large");
return;
}
t = (zic_t) dayoff * SECSPERDAY;
- tod = gethms(fields[LP_TIME], _("invalid time of day"), FALSE);
+ tod = gethms(fields[LP_TIME], "invalid time of day", FALSE);
cp = fields[LP_CORR];
{
int positive;
positive = TRUE;
count = 2;
} else {
- error(_("illegal CORRECTION field on Leap line"));
+ 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"));
+ error("illegal Rolling/Stationary field on Leap line");
return;
}
leapadd(tadd(t, tod), positive, lp->l_value, count);
struct link l;
if (nfields != LINK_FIELDS) {
- error(_("wrong number of fields on Link line"));
+ error("wrong number of fields on Link line");
return;
}
if (*fields[LF_FROM] == '\0') {
- error(_("blank FROM field on Link line"));
+ error("blank FROM field on Link line");
return;
}
if (*fields[LF_TO] == '\0') {
- error(_("blank TO field on Link line"));
+ error("blank TO field on Link line");
return;
}
l.l_filename = filename;
}
static void
-rulesub(rp, loyearp, hiyearp, typep, monthp, dayp, timep)
-struct rule * const rp;
-const char * const loyearp;
-const char * const hiyearp;
-const char * const typep;
-const char * const monthp;
-const char * const dayp;
-const char * const timep;
+rulesub(struct rule * const rp, const char * const loyearp,
+ const char * const hiyearp, const char * const typep,
+ const char * const monthp, const char * const dayp,
+ const char * const timep)
{
- const struct lookup * lp;
- const char * cp;
- char * dp;
- char * ep;
+ const struct lookup *lp;
+ const char *cp;
+ char *dp, *ep;
if ((lp = byword(monthp, mon_names)) == NULL) {
- error(_("invalid month name"));
+ error("invalid month name");
return;
}
rp->r_month = lp->l_value;
if (*dp != '\0') {
ep = dp + strlen(dp) - 1;
switch (tolower((unsigned char)*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;
+ 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);
+ rp->r_tod = gethms(dp, "invalid time of day", FALSE);
free(dp);
/*
** Year work.
default: /* "cannot happen" */
errx(1, "panic: Invalid l_value %d", lp->l_value);
} else if (sscanf(cp, scheck(cp, "%d"), &rp->r_loyear) != 1) {
- error(_("invalid starting year"));
+ error("invalid starting year");
return;
}
cp = hiyearp;
default: /* "cannot happen" */
errx(1, "panic: Invalid l_value %d", lp->l_value);
} else if (sscanf(cp, scheck(cp, "%d"), &rp->r_hiyear) != 1) {
- error(_("invalid ending year"));
+ error("invalid ending year");
return;
}
if (rp->r_loyear > rp->r_hiyear) {
- error(_("starting year greater than ending year"));
+ 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"));
+ error("typed single year");
return;
}
rp->r_yrtype = ecpyalloc(typep);
if (rp->r_dycode != DC_DOM) {
*ep++ = 0;
if (*ep++ != '=') {
- error(_("invalid day of month"));
+ error("invalid day of month");
free(dp);
return;
}
if ((lp = byword(dp, wday_names)) == NULL) {
- error(_("invalid weekday name"));
+ error("invalid weekday name");
free(dp);
return;
}
rp->r_wday = lp->l_value;
}
if (sscanf(ep, scheck(ep, "%d"), &rp->r_dayofmonth) != 1 ||
- rp->r_dayofmonth <= 0 ||
- (rp->r_dayofmonth > len_months[1][rp->r_month])) {
- error(_("invalid day of month"));
- free(dp);
- return;
+ rp->r_dayofmonth <= 0 ||
+ (rp->r_dayofmonth > len_months[1][rp->r_month])) {
+ error("invalid day of month");
+ free(dp);
+ return;
}
}
free(dp);
static void
writezone(const char *name, const char *string)
{
- FILE * fp;
+ FILE *fp;
int i, j;
int leapcnt32, leapi32;
int timecnt32, timei32;
int pass;
- static char * fullname;
+ static char *fullname;
static const struct tzhead tzh0;
- static struct tzhead tzh;
- zic_t ats[TZ_MAX_TIMES];
- unsigned char types[TZ_MAX_TIMES];
- size_t len;
+ static struct tzhead tzh;
+ zic_t ats[TZ_MAX_TIMES];
+ unsigned char types[TZ_MAX_TIMES];
+ size_t len;
/*
** Sort.
++fromi; /* handled by default rule */
for ( ; fromi < timecnt; ++fromi) {
if (toi != 0 && ((attypes[fromi].at +
- gmtoffs[attypes[toi - 1].type]) <=
- (attypes[toi - 1].at + gmtoffs[toi == 1 ? 0
- : attypes[toi - 2].type]))) {
- attypes[toi - 1].type =
- attypes[fromi].type;
- continue;
+ gmtoffs[attypes[toi - 1].type]) <=
+ (attypes[toi - 1].at + gmtoffs[toi == 1 ? 0 :
+ attypes[toi - 2].type]))) {
+ attypes[toi - 1].type = attypes[fromi].type;
+ continue;
}
if (toi == 0 ||
- attypes[toi - 1].type != attypes[fromi].type)
- attypes[toi++] = attypes[fromi];
+ attypes[toi - 1].type != attypes[fromi].type)
+ attypes[toi++] = attypes[fromi];
}
timecnt = toi;
}
/*
** Remove old file, if any, to snap links.
*/
- if (!itsdir(fullname) && remove(fullname) != 0 && errno != ENOENT) {
+ if (!itsdir(fullname) && remove(fullname) != 0 && errno != ENOENT)
err(1, "Can't remove %s", fullname);
- }
if ((fp = fopen(fullname, "wb")) == NULL) {
if (mkdirs(fullname) != 0)
exit(EXIT_FAILURE);
- if ((fp = fopen(fullname, "wb")) == NULL) {
+ if ((fp = fopen(fullname, "wb")) == NULL)
err(1, "Can't create %s", fullname);
- }
}
for (pass = 1; pass <= 2; ++pass) {
int thistimei, thistimecnt;
int thisleapi, thisleapcnt;
int thistimelim, thisleaplim;
- int writetype[TZ_MAX_TIMES];
- int typemap[TZ_MAX_TYPES];
+ int writetype[TZ_MAX_TIMES];
+ int typemap[TZ_MAX_TYPES];
int thistypecnt;
- char thischars[TZ_MAX_CHARS];
- char thischarcnt;
- int indmap[TZ_MAX_CHARS];
+ char thischars[TZ_MAX_CHARS];
+ char thischarcnt;
+ int indmap[TZ_MAX_CHARS];
if (pass == 1) {
thistimei = timei32;
for (i = thistimei; i < thistimelim; ++i)
if (isdsts[types[i]])
mrudst = types[i];
- else mrustd = types[i];
+ else
+ mrustd = types[i];
for (i = 0; i < typecnt; ++i)
if (writetype[i]) {
if (isdsts[i])
hidst = i;
- else histd = 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] = TRUE;
- writetype[type] = TRUE;
+ gmtoffs[hidst] != gmtoffs[mrudst]) {
+ isdsts[mrudst] = -1;
+ type = addtype(gmtoffs[mrudst],
+ &chars[abbrinds[mrudst]],
+ TRUE, ttisstds[mrudst],
+ ttisgmts[mrudst]);
+ isdsts[mrudst] = TRUE;
+ 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] = FALSE;
- writetype[type] = TRUE;
+ gmtoffs[histd] != gmtoffs[mrustd]) {
+ isdsts[mrustd] = -1;
+ type = addtype(gmtoffs[mrustd],
+ &chars[abbrinds[mrustd]],
+ FALSE, ttisstds[mrustd],
+ ttisgmts[mrustd]);
+ isdsts[mrustd] = FALSE;
+ writetype[type] = TRUE;
}
}
#endif /* !defined LEAVE_SOME_PRE_2011_SYSTEMS_IN_THE_LURCH */
indmap[i] = -1;
thischarcnt = 0;
for (i = 0; i < typecnt; ++i) {
- char * thisabbr;
+ char *thisabbr;
if (!writetype[i])
continue;
break;
if (j == thischarcnt) {
strlcpy(&thischars[(int) thischarcnt],
- thisabbr, sizeof(thischars) - thischarcnt);
+ thisabbr, sizeof(thischars) - thischarcnt);
thischarcnt += strlen(thisabbr) + 1;
}
indmap[abbrinds[i]] = j;
for (i = thistimei; i < thistimelim; ++i)
if (pass == 1)
puttzcode((long) ats[i], fp);
- else puttzcode64(ats[i], fp);
+ else
+ puttzcode64(ats[i], fp);
for (i = thistimei; i < thistimelim; ++i) {
unsigned char uc;
if (writetype[i]) {
puttzcode(gmtoffs[i], fp);
putc(isdsts[i], fp);
- putc((unsigned char) indmap[abbrinds[i]], fp);
+ putc((unsigned char)indmap[abbrinds[i]], fp);
}
if (thischarcnt != 0)
fwrite(thischars, sizeof thischars[0], thischarcnt, fp);
} else {
j = 1;
while (j < timecnt &&
- trans[i] >= ats[j])
- ++j;
+ trans[i] >= ats[j])
+ ++j;
j = types[j - 1];
}
todo = tadd(trans[i], -gmtoffs[j]);
- } else todo = trans[i];
+ } else
+ todo = trans[i];
if (pass == 1)
puttzcode((long) todo, fp);
- else puttzcode64(todo, fp);
+ else
+ puttzcode64(todo, fp);
puttzcode(corr[i], fp);
}
for (i = 0; i < typecnt; ++i)
putc(ttisgmts[i], fp);
}
fprintf(fp, "\n%s\n", string);
- if (ferror(fp) || fclose(fp)) {
+ if (ferror(fp) || fclose(fp))
errx(1, "Error writing %s", fullname);
- }
}
static void
-doabbr(char *abbr, size_t size, const char *format, const char *letters, int isdst, int doquotes)
+doabbr(char *abbr, size_t size, const char *format, const char *letters,
+ int isdst, int doquotes)
{
- char * cp;
- char * slashp;
+ char *cp, *slashp;
int len;
slashp = strchr(format, '/');
if (slashp == NULL) {
if (letters == NULL)
strlcpy(abbr, format, size);
- else snprintf(abbr, size, format, letters);
+ else
+ snprintf(abbr, size, format, letters);
} else if (isdst) {
strlcpy(abbr, slashp + 1, size);
} else {
static int
stringoffset(char *result, size_t size, long offset)
{
- int hours;
- int minutes;
- int seconds;
- char * ep;
+ int hours, minutes, seconds;
+ char *ep;
result[0] = '\0';
if (offset < 0) {
stringrule(char *result, size_t size, const struct rule *rp, long dstoff, long gmtoff)
{
long tod;
- char * ep;
+ char *ep;
ep = end(result, size);
size -= ep - result;
return -1;
week = rp->r_dayofmonth / DAYSPERWEEK;
}
- } else return -1; /* "cannot happen" */
+ } else
+ return -1; /* "cannot happen" */
snprintf(result, size, "M%d.%d.%d",
rp->r_month + 1, week, rp->r_wday);
}
static void
stringzone(char *result, size_t size, const struct zone *zpfirst, int zonecount)
{
- const struct zone * zp;
- struct rule * rp;
- struct rule * stdrp;
- struct rule * dstrp;
+ const struct zone *zp;
+ struct rule *rp, *stdrp, *dstrp;
int i;
- const char * abbrvar;
- char * ep;
+ const char *abbrvar;
+ char *ep;
result[0] = '\0';
zp = zpfirst + zonecount - 1;
if (rp->r_stdoff == 0) {
if (stdrp == NULL)
stdrp = rp;
- else return;
+ else
+ return;
} else {
if (dstrp == NULL)
dstrp = rp;
- else return;
+ else
+ return;
}
}
if (stdrp == NULL && dstrp == NULL) {
static void
outzone(const struct zone *zpfirst, int zonecount)
{
- const struct zone * zp;
- struct rule * rp;
- int i, j;
- int usestart, useuntil;
- zic_t starttime, untiltime;
- long gmtoff;
- long stdoff;
- int year;
- long startoff;
- int startttisstd;
- int startttisgmt;
- int type;
- char * startbuf;
- char * ab;
- char * envvar;
- int max_abbr_len;
- int max_envvar_len;
+ const struct zone *zp;
+ struct rule *rp;
+ int i, j, usestart, useuntil, type;
+ zic_t starttime = 0, untiltime = 0;
+ long gmtoff, stdoff, startoff;
+ int year, startttisstd = FALSE, startttisgmt = FALSE;
+ char *startbuf, *ab, *envvar;
+ int max_abbr_len, max_envvar_len;
int prodstic; /* all rules are min to max */
max_abbr_len = 2 + max_format_len + max_abbrvar_len;
startbuf = emalloc(max_abbr_len + 1);
ab = emalloc(max_abbr_len + 1);
envvar = emalloc(max_envvar_len + 1);
- untiltime = 0;
- starttime = 0;
/*
** Now. . .finally. . .generate some useful data!
*/
** 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);
if (noise && envvar[0] == '\0') {
char * wp;
- wp = ecpyalloc(_("no POSIX environment variable for zone"));
+ wp = ecpyalloc("no POSIX environment variable for zone");
wp = ecatalloc(wp, " ");
wp = ecatalloc(wp, zpfirst->z_name);
warning(wp);
if (envvar[0] == '\0') {
if (min_year >= INT_MIN + YEARSPERREPEAT)
min_year -= YEARSPERREPEAT;
- else min_year = INT_MIN;
+ else
+ min_year = INT_MIN;
if (max_year <= INT_MAX - YEARSPERREPEAT)
max_year += YEARSPERREPEAT;
- else max_year = INT_MAX;
+ else
+ max_year = INT_MAX;
/*
** Regardless of any of the above,
** for a "proDSTic" zone which specifies that its rules
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);
+ year <= rp->r_hiyear &&
+ yearistype(year, rp->r_yrtype);
if (rp->r_todo)
rp->r_temp = rpytime(rp, year);
}
for ( ; ; ) {
int k;
- zic_t jtime, ktime;
+ zic_t jtime, ktime = 0;
long offset;
- ktime = 0;
if (useuntil) {
/*
** Turn untiltime into UTC
if (usestart) {
if (ktime < starttime) {
startoff = oadd(zp->z_gmtoff,
- stdoff);
+ stdoff);
doabbr(startbuf,
- max_abbr_len + 1,
- zp->z_format,
- rp->r_abbrvar,
- rp->r_stdoff != 0,
- FALSE);
+ max_abbr_len + 1,
+ zp->z_format,
+ rp->r_abbrvar,
+ rp->r_stdoff != 0,
+ FALSE);
continue;
}
if (*startbuf == '\0' &&
- startoff == oadd(zp->z_gmtoff,
- stdoff)) {
- doabbr(startbuf,
- max_abbr_len + 1,
- zp->z_format,
- rp->r_abbrvar,
- rp->r_stdoff !=
- 0,
- FALSE);
+ startoff == oadd(zp->z_gmtoff,
+ stdoff)) {
+ doabbr(startbuf,
+ max_abbr_len + 1,
+ zp->z_format,
+ rp->r_abbrvar,
+ rp->r_stdoff != 0,
+ FALSE);
}
}
eats(zp->z_filename, zp->z_linenum,
- rp->r_filename, rp->r_linenum);
+ rp->r_filename, rp->r_linenum);
doabbr(ab, max_abbr_len + 1, zp->z_format,
- rp->r_abbrvar,
- rp->r_stdoff != 0, FALSE);
+ rp->r_abbrvar, rp->r_stdoff != 0, FALSE);
offset = oadd(zp->z_gmtoff, rp->r_stdoff);
type = addtype(offset, ab, rp->r_stdoff != 0,
- rp->r_todisstd, rp->r_todisgmt);
+ rp->r_todisstd, rp->r_todisgmt);
addtt(ktime, type);
}
}
if (usestart) {
if (*startbuf == '\0' &&
- zp->z_format != NULL &&
- strchr(zp->z_format, '%') == NULL &&
- strchr(zp->z_format, '/') == NULL)
- strlcpy(startbuf, zp->z_format,
- max_abbr_len + 1);
+ zp->z_format != NULL &&
+ strchr(zp->z_format, '%') == NULL &&
+ strchr(zp->z_format, '/') == NULL)
+ strlcpy(startbuf, zp->z_format, max_abbr_len + 1);
eat(zp->z_filename, zp->z_linenum);
if (*startbuf == '\0')
- error(_("can't determine time zone abbreviation to use just after until time"));
- else addtt(starttime,
- addtype(startoff, startbuf,
- startoff != zp->z_gmtoff,
- startttisstd,
- startttisgmt));
+ error("can't 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.
}
static void
-addtt(starttime, type)
-const zic_t starttime;
-int type;
+addtt(const zic_t starttime, int type)
{
size_t len;
if (starttime <= min_time ||
- (timecnt == 1 && attypes[0].at < min_time)) {
+ (timecnt == 1 && attypes[0].at < min_time)) {
gmtoffs[0] = gmtoffs[type];
isdsts[0] = isdsts[type];
ttisstds[0] = ttisstds[type];
type = 0;
}
if (timecnt >= TZ_MAX_TIMES) {
- error(_("too many transitions?!"));
+ error("too many transitions?!");
exit(EXIT_FAILURE);
}
attypes[timecnt].at = starttime;
int i, j;
if (isdst != TRUE && isdst != FALSE) {
- error(_("internal error - addtype called with bad isdst"));
+ error("internal error - addtype called with bad isdst");
exit(EXIT_FAILURE);
}
if (ttisstd != TRUE && ttisstd != FALSE) {
- error(_("internal error - addtype called with bad ttisstd"));
+ error("internal error - addtype called with bad ttisstd");
exit(EXIT_FAILURE);
}
if (ttisgmt != TRUE && ttisgmt != FALSE) {
- error(_("internal error - addtype called with bad ttisgmt"));
+ error("internal error - addtype called with bad ttisgmt");
exit(EXIT_FAILURE);
}
/*
*/
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;
+ 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"));
+ error("too many local time types");
exit(EXIT_FAILURE);
}
if (! (-1L - 2147483647L <= gmtoff && gmtoff <= 2147483647L)) {
- error(_("UTC offset out of range"));
+ error("UTC offset out of range");
exit(EXIT_FAILURE);
}
gmtoffs[i] = gmtoff;
int i, j;
if (leapcnt + (positive ? count : 1) > TZ_MAX_LEAPS) {
- error(_("too many leap seconds"));
+ error("too many leap seconds");
exit(EXIT_FAILURE);
}
for (i = 0; i < leapcnt; ++i)
if (t <= trans[i]) {
if (t == trans[i]) {
- error(_("repeated leap second moment"));
+ error("repeated leap second moment");
exit(EXIT_FAILURE);
}
break;
static int
yearistype(int year, const char *type)
{
- static char * buf;
+ static char *buf;
int result;
size_t len;
buf = erealloc(buf, len);
snprintf(buf, len, "%s %d %s", yitcommand, year, type);
result = system(buf);
- if (WIFEXITED(result)) switch (WEXITSTATUS(result)) {
+ if (WIFEXITED(result))
+ switch (WEXITSTATUS(result)) {
case 0:
return TRUE;
case 1:
return FALSE;
- }
- error(_("Wild result from command execution"));
+ }
+ error("Wild result from command execution");
errx(1, "command was '%s', result was %d", buf, result);
}
static const struct lookup *
byword(const char *word, const struct lookup *table)
{
- const struct lookup * foundlp;
- const struct lookup * lp;
+ const struct lookup *foundlp;
+ const struct lookup *lp;
if (word == NULL || table == NULL)
return NULL;
static char **
getfields(char *cp)
{
- char * dp;
- char ** array;
+ char *dp;
+ char **array;
int nsubs;
if (cp == NULL)
array = ereallocarray(NULL, strlen(cp) + 1, sizeof *array);
nsubs = 0;
for ( ; ; ) {
- while (isascii((unsigned char) *cp) &&
- isspace((unsigned char) *cp))
- ++cp;
+ while (isascii((unsigned char)*cp) &&
+ isspace((unsigned char)*cp))
+ ++cp;
if (*cp == '\0' || *cp == '#')
break;
array[nsubs++] = dp = cp;
do {
- if ((*dp = *cp++) != '"')
+ if ((*dp = *cp++) != '"') {
++dp;
- else while ((*dp = *cp++) != '"')
- if (*dp != '\0')
- ++dp;
- else {
- error(_( "Odd number of quotation marks"));
- exit(EXIT_FAILURE);
+ } else {
+ while ((*dp = *cp++) != '"') {
+ if (*dp != '\0')
+ ++dp;
+ else {
+ error("Odd number of quotation marks");
+ exit(EXIT_FAILURE);
+ }
}
+ }
} while (*cp != '\0' && *cp != '#' &&
- (!isascii((unsigned char)*cp) || !isspace((unsigned char) *cp)));
- if (isascii((unsigned char) *cp) && isspace((unsigned char) *cp))
+ (!isascii((unsigned char)*cp) || !isspace((unsigned char)*cp)));
+ if (isascii((unsigned char)*cp) && isspace((unsigned char)*cp))
++cp;
*dp = '\0';
}
static long
oadd(long t1, long t2)
{
- long t;
+ long t = t1 + t2;
- t = t1 + t2;
if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
- error(_("time overflow"));
+ error("time overflow");
exit(EXIT_FAILURE);
}
return t;
return min_time;
t = t1 + t2;
if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
- error(_("time overflow"));
+ error("time overflow");
exit(EXIT_FAILURE);
}
return t;
** Given a rule, and a year, compute the date - in seconds since January 1,
** 1970, 00:00 LOCAL time - in that year that the rule refers to.
*/
-
static zic_t
rpytime(const struct rule *rp, int wantedy)
{
if (rp->r_dycode == DC_DOWLEQ)
--i;
else {
- error(_("use of 2/29 in non leap-year"));
+ error("use of 2/29 in non leap-year");
exit(EXIT_FAILURE);
}
}
*/
cp = string;
wp = NULL;
- while (isascii((unsigned char) *cp) &&
- isalpha((unsigned char) *cp))
- ++cp;
+ while (isascii((unsigned char)*cp) &&
+ isalpha((unsigned char)*cp))
+ ++cp;
if (cp - string == 0)
-wp = _("time zone abbreviation lacks alphabetic at start");
+ wp = "time zone abbreviation lacks alphabetic at start";
if (noise && cp - string > 3)
-wp = _("time zone abbreviation has more than 3 alphabetics");
+ wp = "time zone abbreviation has more than 3 alphabetics";
if (cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
-wp = _("time zone abbreviation has too many alphabetics");
+ wp = "time zone abbreviation has too many alphabetics";
if (wp == NULL && (*cp == '+' || *cp == '-')) {
++cp;
- if (isascii((unsigned char) *cp) &&
- isdigit((unsigned char) *cp))
- if (*cp++ == '1' &&
- *cp >= '0' && *cp <= '4')
- ++cp;
+ if (isascii((unsigned char)*cp) &&
+ isdigit((unsigned char)*cp))
+ if (*cp++ == '1' && *cp >= '0' && *cp <= '4')
+ ++cp;
}
if (*cp != '\0')
- wp = _("time zone abbreviation differs from POSIX standard");
+ wp = "time zone abbreviation differs from POSIX standard";
if (wp != NULL) {
wp = ecpyalloc(wp);
wp = ecatalloc(wp, " (");
}
i = strlen(string) + 1;
if (charcnt + i > TZ_MAX_CHARS) {
- error(_("too many, or too long, time zone abbreviations"));
+ error("too many, or too long, time zone abbreviations");
exit(EXIT_FAILURE);
}
strlcpy(&chars[charcnt], string, sizeof(chars) - charcnt);
if (errno != EEXIST || !itsdir(name)) {
fprintf(stderr,
- _("%s: Can't create directory %s: %s\n"),
- progname, name, e);
+ "%s: Can't create directory %s: %s\n",
+ __progname, name, e);
free(name);
return -1;
}
static long
eitol(int i)
{
- long l;
+ long l = i;
- l = i;
- if ((i < 0 && l >= 0) || (i == 0 && l != 0) || (i > 0 && l <= 0)) {
+ if ((i < 0 && l >= 0) || (i == 0 && l != 0) || (i > 0 && l <= 0))
errx(1, "%d did not sign extend correctly", i);
- }
return l;
}
projects / openbsd / commitdiff