** 5. They might reference tm.TM_ZONE after calling offtime.
** What's best to do in the above cases is open to debate;
** for now, we just set things up so that in any of the five cases
-** WILDABBR is used. Another possibility: initialize tzname[0] to the
+** WILDABBR is used. Another possibility: initialize tzname[0] to the
** string "tzname[0] used before set", and similarly for the other cases.
** And another: initialize tzname[0] to "ERA", with an explanation in the
** manual page of what this "time zone abbreviation" means (doing this so
** that tzname[0] has the "normal" length of three characters).
*/
#define WILDABBR " "
-#endif /* !defined WILDABBR */
+#endif /* !defined WILDABBR */
-static char wildabbr[] = "WILDABBR";
+static char wildabbr[] = "WILDABBR";
-static const char gmt[] = "GMT";
+static const char gmt[] = "GMT";
/*
** The DST rules to use if TZ has no rules and we can't load TZDEFRULES.
*/
#define TZDEFRULESTRING ",M4.1.0,M10.5.0"
-struct ttinfo { /* time type information */
- long tt_gmtoff; /* UTC offset in seconds */
- int tt_isdst; /* used to set tm_isdst */
- int tt_abbrind; /* abbreviation list index */
- int tt_ttisstd; /* TRUE if transition is std time */
- int tt_ttisgmt; /* TRUE if transition is UTC */
+struct ttinfo
+{ /* time type information */
+ long tt_gmtoff; /* UTC offset in seconds */
+ int tt_isdst; /* used to set tm_isdst */
+ int tt_abbrind; /* abbreviation list index */
+ int tt_ttisstd; /* TRUE if transition is std time */
+ int tt_ttisgmt; /* TRUE if transition is UTC */
};
-struct lsinfo { /* leap second information */
- time_t ls_trans; /* transition time */
- long ls_corr; /* correction to apply */
+struct lsinfo
+{ /* leap second information */
+ time_t ls_trans; /* transition time */
+ long ls_corr; /* correction to apply */
};
#define BIGGEST(a, b) (((a) > (b)) ? (a) : (b))
-struct state {
- int leapcnt;
- int timecnt;
- int typecnt;
- int charcnt;
+struct state
+{
+ int leapcnt;
+ int timecnt;
+ int typecnt;
+ int charcnt;
time_t ats[TZ_MAX_TIMES];
- unsigned char types[TZ_MAX_TIMES];
- struct ttinfo ttis[TZ_MAX_TYPES];
+ unsigned char types[TZ_MAX_TIMES];
+ struct ttinfo ttis[TZ_MAX_TYPES];
char chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt),
- (2 * (TZ_STRLEN_MAX + 1)))];
- struct lsinfo lsis[TZ_MAX_LEAPS];
+ (2 * (TZ_STRLEN_MAX + 1)))];
+ struct lsinfo lsis[TZ_MAX_LEAPS];
};
-struct rule {
- int r_type; /* type of rule--see below */
- int r_day; /* day number of rule */
- int r_week; /* week number of rule */
- int r_mon; /* month number of rule */
- long r_time; /* transition time of rule */
+struct rule
+{
+ int r_type; /* type of rule--see below */
+ int r_day; /* day number of rule */
+ int r_week; /* week number of rule */
+ int r_mon; /* month number of rule */
+ long r_time; /* transition time of rule */
};
-#define JULIAN_DAY 0 /* Jn - Julian day */
-#define DAY_OF_YEAR 1 /* n - day of year */
-#define MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d - month, week, day of week */
+#define JULIAN_DAY 0 /* Jn - Julian day */
+#define DAY_OF_YEAR 1 /* n - day of year */
+#define MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d - month, week, day of
+ * week */
/*
** Prototypes for static functions.
static const char *getnum(const char *strp, int *nump, int min, int max);
static const char *getsecs(const char *strp, long *secsp);
static const char *getoffset(const char *strp, long *offsetp);
-static const char *getrule(const char *strp, struct rule *rulep);
-static void gmtload(struct state *sp);
-static void gmtsub(const time_t *timep, long offset, struct pg_tm *tmp);
-static void localsub(const time_t *timep, long offset, struct pg_tm *tmp);
-static int increment_overflow(int *number, int delta);
-static int normalize_overflow(int *tensptr, int *unitsptr, int base);
-static time_t time1(struct pg_tm *tmp, void(*funcp)(const time_t *, long, struct pg_tm *), long offset);
-static time_t time2(struct pg_tm *tmp, void(*funcp)(const time_t *, long, struct pg_tm *), long offset, int *okayp);
-static time_t time2sub(struct pg_tm *tmp, void(*funcp)(const time_t *, long, struct pg_tm *), long offset, int *okayp, int do_norm_secs);
-static void timesub(const time_t *timep, long offset, const struct state *sp, struct pg_tm *tmp);
-static int tmcomp(const struct pg_tm *atmp, const struct pg_tm *btmp);
-static time_t transtime(time_t janfirst, int year, const struct rule *rulep, long offset);
-static int tzload(const char *name, struct state *sp);
-static int tzparse(const char *name, struct state *sp, int lastditch);
-
-static struct state lclmem;
-static struct state gmtmem;
+static const char *getrule(const char *strp, struct rule * rulep);
+static void gmtload(struct state * sp);
+static void gmtsub(const time_t *timep, long offset, struct pg_tm * tmp);
+static void localsub(const time_t *timep, long offset, struct pg_tm * tmp);
+static int increment_overflow(int *number, int delta);
+static int normalize_overflow(int *tensptr, int *unitsptr, int base);
+static time_t time1(struct pg_tm * tmp, void (*funcp) (const time_t *, long, struct pg_tm *), long offset);
+static time_t time2(struct pg_tm * tmp, void (*funcp) (const time_t *, long, struct pg_tm *), long offset, int *okayp);
+static time_t time2sub(struct pg_tm * tmp, void (*funcp) (const time_t *, long, struct pg_tm *), long offset, int *okayp, int do_norm_secs);
+static void timesub(const time_t *timep, long offset, const struct state * sp, struct pg_tm * tmp);
+static int tmcomp(const struct pg_tm * atmp, const struct pg_tm * btmp);
+static time_t transtime(time_t janfirst, int year, const struct rule * rulep, long offset);
+static int tzload(const char *name, struct state * sp);
+static int tzparse(const char *name, struct state * sp, int lastditch);
+
+static struct state lclmem;
+static struct state gmtmem;
+
#define lclptr (&lclmem)
#define gmtptr (&gmtmem)
-static char lcl_TZname[TZ_STRLEN_MAX + 1];
-static int lcl_is_set=0;
-static int gmt_is_set=0;
+static char lcl_TZname[TZ_STRLEN_MAX + 1];
+static int lcl_is_set = 0;
+static int gmt_is_set = 0;
/*
** Section 4.12.3 of X3.159-1989 requires that
** Thanks to Paul Eggert (eggert@twinsun.com) for noting this.
*/
-static struct pg_tm tm;
+static struct pg_tm tm;
-static long detzcode(const char *codep)
+static long
+detzcode(const char *codep)
{
- register long result;
- register int i;
+ register long result;
+ register int i;
result = (codep[0] & 0x80) ? ~0L : 0L;
for (i = 0; i < 4; ++i)
return result;
}
-static int tzload(register const char *name, register struct state *sp)
+static int
+tzload(register const char *name, register struct state * sp)
{
- register const char * p;
- register int i;
- register int fid;
+ register const char *p;
+ register int i;
+ register int fid;
if (name == NULL && (name = TZDEFAULT) == NULL)
return -1;
{
- register int doaccess;
+ register int doaccess;
char fullname[MAXPGPATH];
if (name[0] == ':')
++name;
doaccess = name[0] == '/';
- if (!doaccess) {
+ if (!doaccess)
+ {
p = pg_TZDIR();
if (p == NULL)
return -1;
(void) strcpy(fullname, p);
(void) strcat(fullname, "/");
(void) strcat(fullname, name);
+
/*
- ** Set doaccess if '.' (as in "../") shows up in name.
- */
+ * * Set doaccess if '.' (as in "../") shows up in name.
+ */
if (strchr(name, '.') != NULL)
doaccess = TRUE;
name = fullname;
return -1;
}
{
- struct tzhead * tzhp;
- union {
- struct tzhead tzhead;
+ struct tzhead *tzhp;
+ union
+ {
+ struct tzhead tzhead;
char buf[sizeof *sp + sizeof *tzhp];
- } u;
- int ttisstdcnt;
- int ttisgmtcnt;
+ } u;
+ int ttisstdcnt;
+ int ttisgmtcnt;
i = read(fid, u.buf, sizeof u.buf);
if (close(fid) != 0)
sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS ||
(ttisstdcnt != sp->typecnt && ttisstdcnt != 0) ||
(ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
- return -1;
- if (i - (p - u.buf) < sp->timecnt * 4 + /* ats */
- sp->timecnt + /* types */
+ return -1;
+ if (i - (p - u.buf) < sp->timecnt * 4 + /* ats */
+ sp->timecnt + /* types */
sp->typecnt * (4 + 2) + /* ttinfos */
- sp->charcnt + /* chars */
+ sp->charcnt + /* chars */
sp->leapcnt * (4 + 4) + /* lsinfos */
- ttisstdcnt + /* ttisstds */
+ ttisstdcnt + /* ttisstds */
ttisgmtcnt) /* ttisgmts */
- return -1;
- for (i = 0; i < sp->timecnt; ++i) {
+ return -1;
+ for (i = 0; i < sp->timecnt; ++i)
+ {
sp->ats[i] = detzcode(p);
p += 4;
}
- for (i = 0; i < sp->timecnt; ++i) {
+ for (i = 0; i < sp->timecnt; ++i)
+ {
sp->types[i] = (unsigned char) *p++;
if (sp->types[i] >= sp->typecnt)
return -1;
}
- for (i = 0; i < sp->typecnt; ++i) {
- register struct ttinfo * ttisp;
+ for (i = 0; i < sp->typecnt; ++i)
+ {
+ register struct ttinfo *ttisp;
ttisp = &sp->ttis[i];
ttisp->tt_gmtoff = detzcode(p);
ttisp->tt_abbrind = (unsigned char) *p++;
if (ttisp->tt_abbrind < 0 ||
ttisp->tt_abbrind > sp->charcnt)
- return -1;
+ return -1;
}
for (i = 0; i < sp->charcnt; ++i)
sp->chars[i] = *p++;
sp->chars[i] = '\0'; /* ensure '\0' at end */
- for (i = 0; i < sp->leapcnt; ++i) {
- register struct lsinfo * lsisp;
+ for (i = 0; i < sp->leapcnt; ++i)
+ {
+ register struct lsinfo *lsisp;
lsisp = &sp->lsis[i];
lsisp->ls_trans = detzcode(p);
lsisp->ls_corr = detzcode(p);
p += 4;
}
- for (i = 0; i < sp->typecnt; ++i) {
- register struct ttinfo * ttisp;
+ for (i = 0; i < sp->typecnt; ++i)
+ {
+ register struct ttinfo *ttisp;
ttisp = &sp->ttis[i];
if (ttisstdcnt == 0)
ttisp->tt_ttisstd = FALSE;
- else {
+ else
+ {
ttisp->tt_ttisstd = *p++;
if (ttisp->tt_ttisstd != TRUE &&
ttisp->tt_ttisstd != FALSE)
- return -1;
+ return -1;
}
}
- for (i = 0; i < sp->typecnt; ++i) {
- register struct ttinfo * ttisp;
+ for (i = 0; i < sp->typecnt; ++i)
+ {
+ register struct ttinfo *ttisp;
ttisp = &sp->ttis[i];
if (ttisgmtcnt == 0)
ttisp->tt_ttisgmt = FALSE;
- else {
+ else
+ {
ttisp->tt_ttisgmt = *p++;
if (ttisp->tt_ttisgmt != TRUE &&
ttisp->tt_ttisgmt != FALSE)
- return -1;
+ return -1;
}
}
}
return 0;
}
-static const int mon_lengths[2][MONSPERYEAR] = {
- { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
- { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
+static const int mon_lengths[2][MONSPERYEAR] = {
+ {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+ {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
-static const int year_lengths[2] = {
+static const int year_lengths[2] = {
DAYSPERNYEAR, DAYSPERLYEAR
};
** character.
*/
-static const char *getzname(register const char *strp)
+static const char *
+getzname(register const char *strp)
{
- register char c;
+ register char c;
while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' &&
- c != '+')
- ++strp;
+ c != '+')
+ ++strp;
return strp;
}
** Otherwise, return a pointer to the first character not part of the number.
*/
-static const char *getnum(register const char *strp, int *nump, const int min, const int max)
+static const char *
+getnum(register const char *strp, int *nump, const int min, const int max)
{
- register char c;
- register int num;
+ register char c;
+ register int num;
if (strp == NULL || !is_digit(c = *strp))
return NULL;
num = 0;
- do {
+ do
+ {
num = num * 10 + (c - '0');
if (num > max)
- return NULL; /* illegal value */
+ return NULL; /* illegal value */
c = *++strp;
} while (is_digit(c));
if (num < min)
- return NULL; /* illegal value */
+ return NULL; /* illegal value */
*nump = num;
return strp;
}
** of seconds.
*/
-static const char *getsecs(register const char *strp, long *secsp)
+static const char *
+getsecs(register const char *strp, long *secsp)
{
- int num;
+ int num;
/*
- ** `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like
- ** "M10.4.6/26", which does not conform to Posix,
- ** but which specifies the equivalent of
- ** ``02:00 on the first Sunday on or after 23 Oct''.
- */
+ * * `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like *
+ * "M10.4.6/26", which does not conform to Posix, * but which
+ * specifies the equivalent of * ``02:00 on the first Sunday on or
+ * after 23 Oct''.
+ */
strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1);
if (strp == NULL)
return NULL;
*secsp = num * (long) SECSPERHOUR;
- if (*strp == ':') {
+ if (*strp == ':')
+ {
++strp;
strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
if (strp == NULL)
return NULL;
*secsp += num * SECSPERMIN;
- if (*strp == ':') {
+ if (*strp == ':')
+ {
++strp;
/* `SECSPERMIN' allows for leap seconds. */
strp = getnum(strp, &num, 0, SECSPERMIN);
** Otherwise, return a pointer to the first character not part of the time.
*/
-static const char *getoffset(register const char *strp, long *offsetp)
+static const char *
+getoffset(register const char *strp, long *offsetp)
{
- register int neg = 0;
+ register int neg = 0;
- if (*strp == '-') {
+ if (*strp == '-')
+ {
neg = 1;
++strp;
- } else if (*strp == '+')
+ }
+ else if (*strp == '+')
++strp;
strp = getsecs(strp, offsetp);
if (strp == NULL)
- return NULL; /* illegal time */
+ return NULL; /* illegal time */
if (neg)
*offsetp = -*offsetp;
return strp;
** Otherwise, return a pointer to the first character not part of the rule.
*/
-static const char *getrule(const char *strp, register struct rule *rulep)
+static const char *
+getrule(const char *strp, register struct rule * rulep)
{
- if (*strp == 'J') {
+ if (*strp == 'J')
+ {
/*
- ** Julian day.
- */
+ * * Julian day.
+ */
rulep->r_type = JULIAN_DAY;
++strp;
strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);
- } else if (*strp == 'M') {
+ }
+ else if (*strp == 'M')
+ {
/*
- ** Month, week, day.
- */
+ * * Month, week, day.
+ */
rulep->r_type = MONTH_NTH_DAY_OF_WEEK;
++strp;
strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);
if (*strp++ != '.')
return NULL;
strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);
- } else if (is_digit(*strp)) {
+ }
+ else if (is_digit(*strp))
+ {
/*
- ** Day of year.
- */
+ * * Day of year.
+ */
rulep->r_type = DAY_OF_YEAR;
strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
- } else return NULL; /* invalid format */
+ }
+ else
+ return NULL; /* invalid format */
if (strp == NULL)
return NULL;
- if (*strp == '/') {
+ if (*strp == '/')
+ {
/*
- ** Time specified.
- */
+ * * Time specified.
+ */
++strp;
strp = getsecs(strp, &rulep->r_time);
- } else rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */
+ }
+ else
+ rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */
return strp;
}
** calculate the Epoch-relative time that rule takes effect.
*/
-static time_t transtime(const time_t janfirst, const int year, register const struct rule *rulep, const long offset)
+static time_t
+transtime(const time_t janfirst, const int year, register const struct rule * rulep, const long offset)
{
- register int leapyear;
- register time_t value = 0;
- register int i;
- int d, m1, yy0, yy1, yy2, dow;
+ register int leapyear;
+ register time_t value = 0;
+ register int i;
+ int d,
+ m1,
+ yy0,
+ yy1,
+ yy2,
+ dow;
leapyear = isleap(year);
- switch (rulep->r_type) {
+ switch (rulep->r_type)
+ {
- case JULIAN_DAY:
- /*
- ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap
- ** years.
- ** In non-leap years, or if the day number is 59 or less, just
- ** add SECSPERDAY times the day number-1 to the time of
- ** January 1, midnight, to get the day.
- */
- value = janfirst + (rulep->r_day - 1) * SECSPERDAY;
- if (leapyear && rulep->r_day >= 60)
- value += SECSPERDAY;
- break;
-
- case DAY_OF_YEAR:
- /*
- ** n - day of year.
- ** Just add SECSPERDAY times the day number to the time of
- ** January 1, midnight, to get the day.
- */
- value = janfirst + rulep->r_day * SECSPERDAY;
- break;
-
- case MONTH_NTH_DAY_OF_WEEK:
- /*
- ** Mm.n.d - nth "dth day" of month m.
- */
- value = janfirst;
- for (i = 0; i < rulep->r_mon - 1; ++i)
- value += mon_lengths[leapyear][i] * SECSPERDAY;
+ case JULIAN_DAY:
- /*
- ** Use Zeller's Congruence to get day-of-week of first day of
- ** month.
- */
- m1 = (rulep->r_mon + 9) % 12 + 1;
- yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
- yy1 = yy0 / 100;
- yy2 = yy0 % 100;
- dow = ((26 * m1 - 2) / 10 +
- 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
- if (dow < 0)
- dow += DAYSPERWEEK;
+ /*
+ * * Jn - Julian day, 1 == January 1, 60 == March 1 even in
+ * leap * years. * In non-leap years, or if the day number is
+ * 59 or less, just * add SECSPERDAY times the day number-1 to
+ * the time of * January 1, midnight, to get the day.
+ */
+ value = janfirst + (rulep->r_day - 1) * SECSPERDAY;
+ if (leapyear && rulep->r_day >= 60)
+ value += SECSPERDAY;
+ break;
- /*
- ** "dow" is the day-of-week of the first day of the month. Get
- ** the day-of-month (zero-origin) of the first "dow" day of the
- ** month.
- */
- d = rulep->r_day - dow;
- if (d < 0)
- d += DAYSPERWEEK;
- for (i = 1; i < rulep->r_week; ++i) {
- if (d + DAYSPERWEEK >=
- mon_lengths[leapyear][rulep->r_mon - 1])
+ case DAY_OF_YEAR:
+
+ /*
+ * * n - day of year. * Just add SECSPERDAY times the day
+ * number to the time of * January 1, midnight, to get the
+ * day.
+ */
+ value = janfirst + rulep->r_day * SECSPERDAY;
+ break;
+
+ case MONTH_NTH_DAY_OF_WEEK:
+
+ /*
+ * * Mm.n.d - nth "dth day" of month m.
+ */
+ value = janfirst;
+ for (i = 0; i < rulep->r_mon - 1; ++i)
+ value += mon_lengths[leapyear][i] * SECSPERDAY;
+
+ /*
+ * * Use Zeller's Congruence to get day-of-week of first day
+ * of * month.
+ */
+ m1 = (rulep->r_mon + 9) % 12 + 1;
+ yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
+ yy1 = yy0 / 100;
+ yy2 = yy0 % 100;
+ dow = ((26 * m1 - 2) / 10 +
+ 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
+ if (dow < 0)
+ dow += DAYSPERWEEK;
+
+ /*
+ * * "dow" is the day-of-week of the first day of the month.
+ * Get * the day-of-month (zero-origin) of the first "dow" day
+ * of the * month.
+ */
+ d = rulep->r_day - dow;
+ if (d < 0)
+ d += DAYSPERWEEK;
+ for (i = 1; i < rulep->r_week; ++i)
+ {
+ if (d + DAYSPERWEEK >=
+ mon_lengths[leapyear][rulep->r_mon - 1])
break;
- d += DAYSPERWEEK;
- }
+ d += DAYSPERWEEK;
+ }
- /*
- ** "d" is the day-of-month (zero-origin) of the day we want.
- */
- value += d * SECSPERDAY;
- break;
+ /*
+ * * "d" is the day-of-month (zero-origin) of the day we want.
+ */
+ value += d * SECSPERDAY;
+ break;
}
/*
- ** "value" is the Epoch-relative time of 00:00:00 UTC on the day in
- ** question. To get the Epoch-relative time of the specified local
- ** time on that day, add the transition time and the current offset
- ** from UTC.
- */
+ * * "value" is the Epoch-relative time of 00:00:00 UTC on the day in *
+ * question. To get the Epoch-relative time of the specified local *
+ * time on that day, add the transition time and the current offset *
+ * from UTC.
+ */
return value + rulep->r_time + offset;
}
** appropriate.
*/
-static int tzparse(const char *name, register struct state *sp, const int lastditch)
+static int
+tzparse(const char *name, register struct state * sp, const int lastditch)
{
- const char * stdname;
- const char * dstname = NULL;
- size_t stdlen;
- size_t dstlen;
- long stdoffset;
- long dstoffset;
- register time_t * atp;
- register unsigned char * typep;
- register char * cp;
- register int load_result;
+ const char *stdname;
+ const char *dstname = NULL;
+ size_t stdlen;
+ size_t dstlen;
+ long stdoffset;
+ long dstoffset;
+ register time_t *atp;
+ register unsigned char *typep;
+ register char *cp;
+ register int load_result;
stdname = name;
- if (lastditch) {
+ if (lastditch)
+ {
stdlen = strlen(name); /* length of standard zone name */
name += stdlen;
if (stdlen >= sizeof sp->chars)
stdlen = (sizeof sp->chars) - 1;
stdoffset = 0;
- } else {
+ }
+ else
+ {
name = getzname(name);
stdlen = name - stdname;
if (stdlen < 3)
load_result = tzload(TZDEFRULES, sp);
if (load_result != 0)
sp->leapcnt = 0; /* so, we're off a little */
- if (*name != '\0') {
+ if (*name != '\0')
+ {
dstname = name;
name = getzname(name);
dstlen = name - dstname; /* length of DST zone name */
if (dstlen < 3)
return -1;
- if (*name != '\0' && *name != ',' && *name != ';') {
+ if (*name != '\0' && *name != ',' && *name != ';')
+ {
name = getoffset(name, &dstoffset);
if (name == NULL)
return -1;
- } else dstoffset = stdoffset - SECSPERHOUR;
+ }
+ else
+ dstoffset = stdoffset - SECSPERHOUR;
if (*name == '\0' && load_result != 0)
name = TZDEFRULESTRING;
- if (*name == ',' || *name == ';') {
- struct rule start;
- struct rule end;
- register int year;
- register time_t janfirst;
+ if (*name == ',' || *name == ';')
+ {
+ struct rule start;
+ struct rule end;
+ register int year;
+ register time_t janfirst;
time_t starttime;
time_t endtime;
if (*name != '\0')
return -1;
sp->typecnt = 2; /* standard time and DST */
+
/*
- ** Two transitions per year, from EPOCH_YEAR to 2037.
- */
+ * * Two transitions per year, from EPOCH_YEAR to 2037.
+ */
sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1);
if (sp->timecnt > TZ_MAX_TIMES)
return -1;
atp = sp->ats;
typep = sp->types;
janfirst = 0;
- for (year = EPOCH_YEAR; year <= 2037; ++year) {
+ for (year = EPOCH_YEAR; year <= 2037; ++year)
+ {
starttime = transtime(janfirst, year, &start,
- stdoffset);
+ stdoffset);
endtime = transtime(janfirst, year, &end,
- dstoffset);
- if (starttime > endtime) {
+ dstoffset);
+ if (starttime > endtime)
+ {
*atp++ = endtime;
- *typep++ = 1; /* DST ends */
+ *typep++ = 1; /* DST ends */
*atp++ = starttime;
- *typep++ = 0; /* DST begins */
- } else {
+ *typep++ = 0; /* DST begins */
+ }
+ else
+ {
*atp++ = starttime;
- *typep++ = 0; /* DST begins */
+ *typep++ = 0; /* DST begins */
*atp++ = endtime;
- *typep++ = 1; /* DST ends */
+ *typep++ = 1; /* DST ends */
}
janfirst += year_lengths[isleap(year)] *
SECSPERDAY;
}
- } else {
- register long theirstdoffset;
- register long theirdstoffset;
- register long theiroffset;
- register int isdst;
- register int i;
- register int j;
+ }
+ else
+ {
+ register long theirstdoffset;
+ register long theirdstoffset;
+ register long theiroffset;
+ register int isdst;
+ register int i;
+ register int j;
if (*name != '\0')
return -1;
+
/*
- ** Initial values of theirstdoffset and theirdstoffset.
- */
+ * * Initial values of theirstdoffset and theirdstoffset.
+ */
theirstdoffset = 0;
- for (i = 0; i < sp->timecnt; ++i) {
+ for (i = 0; i < sp->timecnt; ++i)
+ {
j = sp->types[i];
- if (!sp->ttis[j].tt_isdst) {
+ if (!sp->ttis[j].tt_isdst)
+ {
theirstdoffset =
-sp->ttis[j].tt_gmtoff;
break;
}
}
theirdstoffset = 0;
- for (i = 0; i < sp->timecnt; ++i) {
+ for (i = 0; i < sp->timecnt; ++i)
+ {
j = sp->types[i];
- if (sp->ttis[j].tt_isdst) {
+ if (sp->ttis[j].tt_isdst)
+ {
theirdstoffset =
-sp->ttis[j].tt_gmtoff;
break;
}
}
+
/*
- ** Initially we're assumed to be in standard time.
- */
+ * * Initially we're assumed to be in standard time.
+ */
isdst = FALSE;
theiroffset = theirstdoffset;
+
/*
- ** Now juggle transition times and types
- ** tracking offsets as you do.
- */
- for (i = 0; i < sp->timecnt; ++i) {
+ * * Now juggle transition times and types * tracking offsets
+ * as you do.
+ */
+ for (i = 0; i < sp->timecnt; ++i)
+ {
j = sp->types[i];
sp->types[i] = sp->ttis[j].tt_isdst;
- if (sp->ttis[j].tt_ttisgmt) {
+ if (sp->ttis[j].tt_ttisgmt)
+ {
/* No adjustment to transition time */
- } else {
+ }
+ else
+ {
/*
- ** If summer time is in effect, and the
- ** transition time was not specified as
- ** standard time, add the summer time
- ** offset to the transition time;
- ** otherwise, add the standard time
- ** offset to the transition time.
- */
+ * * If summer time is in effect, and the * transition
+ * time was not specified as * standard time, add the
+ * summer time * offset to the transition time; *
+ * otherwise, add the standard time * offset to the
+ * transition time.
+ */
+
/*
- ** Transitions from DST to DDST
- ** will effectively disappear since
- ** POSIX provides for only one DST
- ** offset.
- */
- if (isdst && !sp->ttis[j].tt_ttisstd) {
+ * * Transitions from DST to DDST * will effectively
+ * disappear since * POSIX provides for only one DST *
+ * offset.
+ */
+ if (isdst && !sp->ttis[j].tt_ttisstd)
+ {
sp->ats[i] += dstoffset -
theirdstoffset;
- } else {
+ }
+ else
+ {
sp->ats[i] += stdoffset -
theirstdoffset;
}
theiroffset = -sp->ttis[j].tt_gmtoff;
if (sp->ttis[j].tt_isdst)
theirdstoffset = theiroffset;
- else theirstdoffset = theiroffset;
+ else
+ theirstdoffset = theiroffset;
}
+
/*
- ** Finally, fill in ttis.
- ** ttisstd and ttisgmt need not be handled.
- */
+ * * Finally, fill in ttis. * ttisstd and ttisgmt need not be
+ * handled.
+ */
sp->ttis[0].tt_gmtoff = -stdoffset;
sp->ttis[0].tt_isdst = FALSE;
sp->ttis[0].tt_abbrind = 0;
sp->ttis[1].tt_abbrind = stdlen + 1;
sp->typecnt = 2;
}
- } else {
+ }
+ else
+ {
dstlen = 0;
sp->typecnt = 1; /* only standard time */
sp->timecnt = 0;
(void) strncpy(cp, stdname, stdlen);
cp += stdlen;
*cp++ = '\0';
- if (dstlen != 0) {
+ if (dstlen != 0)
+ {
(void) strncpy(cp, dstname, dstlen);
*(cp + dstlen) = '\0';
}
return 0;
}
-static void gmtload(struct state *sp)
+static void
+gmtload(struct state * sp)
{
if (tzload(gmt, sp) != 0)
(void) tzparse(gmt, sp, TRUE);
}
-bool pg_tzset(const char *name)
+bool
+pg_tzset(const char *name)
{
if (lcl_is_set && strcmp(lcl_TZname, name) == 0)
- return true; /* no change */
+ return true; /* no change */
if (strlen(name) >= sizeof(lcl_TZname))
return false; /* not gonna fit */
- if (tzload(name, lclptr) != 0) {
+ if (tzload(name, lclptr) != 0)
+ {
if (name[0] == ':' || tzparse(name, lclptr, FALSE) != 0)
{
/* Unknown timezone. Fail our call instead of loading GMT! */
** The unused offset argument is for the benefit of mktime variants.
*/
-static void localsub(const time_t *timep, const long offset, struct pg_tm *tmp)
+static void
+localsub(const time_t *timep, const long offset, struct pg_tm * tmp)
{
- register struct state * sp;
- register const struct ttinfo * ttisp;
- register int i;
- const time_t t = *timep;
+ register struct state *sp;
+ register const struct ttinfo *ttisp;
+ register int i;
+ const time_t t = *timep;
sp = lclptr;
- if (sp->timecnt == 0 || t < sp->ats[0]) {
+ if (sp->timecnt == 0 || t < sp->ats[0])
+ {
i = 0;
while (sp->ttis[i].tt_isdst)
- if (++i >= sp->typecnt) {
+ if (++i >= sp->typecnt)
+ {
i = 0;
break;
}
- } else {
+ }
+ else
+ {
for (i = 1; i < sp->timecnt; ++i)
- if (t < sp->ats[i])
+ if (t < sp->ats[i])
break;
i = sp->types[i - 1];
}
ttisp = &sp->ttis[i];
+
/*
- ** To get (wrong) behavior that's compatible with System V Release 2.0
- ** you'd replace the statement below with
- ** t += ttisp->tt_gmtoff;
- ** timesub(&t, 0L, sp, tmp);
- */
+ * * To get (wrong) behavior that's compatible with System V Release
+ * 2.0 * you'd replace the statement below with * t +=
+ * ttisp->tt_gmtoff; * timesub(&t, 0L, sp, tmp);
+ */
timesub(&t, ttisp->tt_gmtoff, sp, tmp);
tmp->tm_isdst = ttisp->tt_isdst;
tmp->tm_zone = &sp->chars[ttisp->tt_abbrind];
}
-struct pg_tm *pg_localtime(const time_t *timep)
+struct pg_tm *
+pg_localtime(const time_t *timep)
{
localsub(timep, 0L, &tm);
return &tm;
** gmtsub is to gmtime as localsub is to localtime.
*/
-static void gmtsub(const time_t *timep, const long offset, struct pg_tm *tmp)
+static void
+gmtsub(const time_t *timep, const long offset, struct pg_tm * tmp)
{
- if (!gmt_is_set) {
+ if (!gmt_is_set)
+ {
gmt_is_set = TRUE;
gmtload(gmtptr);
}
timesub(timep, offset, gmtptr, tmp);
+
/*
- ** Could get fancy here and deliver something such as
- ** "UTC+xxxx" or "UTC-xxxx" if offset is non-zero,
- ** but this is no time for a treasure hunt.
- */
+ * * Could get fancy here and deliver something such as * "UTC+xxxx"
+ * or "UTC-xxxx" if offset is non-zero, * but this is no time for a
+ * treasure hunt.
+ */
if (offset != 0)
tmp->tm_zone = wildabbr;
- else {
+ else
tmp->tm_zone = gmtptr->chars;
- }
}
-struct pg_tm *pg_gmtime(const time_t *timep)
+struct pg_tm *
+pg_gmtime(const time_t *timep)
{
gmtsub(timep, 0L, &tm);
return &tm;
}
-static void timesub(const time_t *timep, const long offset, register const struct state *sp, register struct pg_tm *tmp)
+static void
+timesub(const time_t *timep, const long offset, register const struct state * sp, register struct pg_tm * tmp)
{
- register const struct lsinfo * lp;
- register long days;
- register long rem;
- register int y;
- register int yleap;
- register const int * ip;
- register long corr;
- register int hit;
- register int i;
+ register const struct lsinfo *lp;
+ register long days;
+ register long rem;
+ register int y;
+ register int yleap;
+ register const int *ip;
+ register long corr;
+ register int hit;
+ register int i;
corr = 0;
hit = 0;
i = sp->leapcnt;
- while (--i >= 0) {
+ while (--i >= 0)
+ {
lp = &sp->lsis[i];
- if (*timep >= lp->ls_trans) {
- if (*timep == lp->ls_trans) {
+ if (*timep >= lp->ls_trans)
+ {
+ if (*timep == lp->ls_trans)
+ {
hit = ((i == 0 && lp->ls_corr > 0) ||
- lp->ls_corr > sp->lsis[i - 1].ls_corr);
+ lp->ls_corr > sp->lsis[i - 1].ls_corr);
if (hit)
while (i > 0 &&
- sp->lsis[i].ls_trans ==
- sp->lsis[i - 1].ls_trans + 1 &&
- sp->lsis[i].ls_corr ==
- sp->lsis[i - 1].ls_corr + 1) {
- ++hit;
- --i;
+ sp->lsis[i].ls_trans ==
+ sp->lsis[i - 1].ls_trans + 1 &&
+ sp->lsis[i].ls_corr ==
+ sp->lsis[i - 1].ls_corr + 1)
+ {
+ ++hit;
+ --i;
}
}
corr = lp->ls_corr;
days = *timep / SECSPERDAY;
rem = *timep % SECSPERDAY;
#ifdef mc68k
- if (*timep == 0x80000000) {
+ if (*timep == 0x80000000)
+ {
/*
- ** A 3B1 muffs the division on the most negative number.
- */
+ * * A 3B1 muffs the division on the most negative number.
+ */
days = -24855;
rem = -11648;
}
-#endif /* defined mc68k */
+#endif /* defined mc68k */
rem += (offset - corr);
- while (rem < 0) {
+ while (rem < 0)
+ {
rem += SECSPERDAY;
--days;
}
- while (rem >= SECSPERDAY) {
+ while (rem >= SECSPERDAY)
+ {
rem -= SECSPERDAY;
++days;
}
tmp->tm_hour = (int) (rem / SECSPERHOUR);
rem = rem % SECSPERHOUR;
tmp->tm_min = (int) (rem / SECSPERMIN);
+
/*
- ** A positive leap second requires a special
- ** representation. This uses "... ??:59:60" et seq.
- */
+ * * A positive leap second requires a special * representation. This
+ * uses "... ??:59:60" et seq.
+ */
tmp->tm_sec = (int) (rem % SECSPERMIN) + hit;
tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);
if (tmp->tm_wday < 0)
tmp->tm_wday += DAYSPERWEEK;
y = EPOCH_YEAR;
#define LEAPS_THRU_END_OF(y) ((y) / 4 - (y) / 100 + (y) / 400)
- while (days < 0 || days >= (long) year_lengths[yleap = isleap(y)]) {
- register int newy;
+ while (days < 0 || days >= (long) year_lengths[yleap = isleap(y)])
+ {
+ register int newy;
newy = y + days / DAYSPERNYEAR;
if (days < 0)
** Simplified normalize logic courtesy Paul Eggert (eggert@twinsun.com).
*/
-static int increment_overflow(int *number, int delta)
+static int
+increment_overflow(int *number, int delta)
{
- int number0;
+ int number0;
number0 = *number;
*number += delta;
return (*number < number0) != (delta < 0);
}
-static int normalize_overflow(int *tensptr, int *unitsptr, const int base)
+static int
+normalize_overflow(int *tensptr, int *unitsptr, const int base)
{
- register int tensdelta;
+ register int tensdelta;
tensdelta = (*unitsptr >= 0) ?
(*unitsptr / base) :
return increment_overflow(tensptr, tensdelta);
}
-static int tmcomp(register const struct pg_tm *atmp, register const struct pg_tm *btmp)
+static int
+tmcomp(register const struct pg_tm * atmp, register const struct pg_tm * btmp)
{
- register int result;
+ register int result;
if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
(result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
(result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
(result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
(result = (atmp->tm_min - btmp->tm_min)) == 0)
- result = atmp->tm_sec - btmp->tm_sec;
+ result = atmp->tm_sec - btmp->tm_sec;
return result;
}
-static time_t time2sub(struct pg_tm *tmp, void(*funcp)(const time_t *, long, struct pg_tm *), const long offset, int *okayp, const int do_norm_secs)
+static time_t time2sub(struct pg_tm * tmp, void (*funcp) (const time_t *, long, struct pg_tm *), const long offset, int *okayp, const int do_norm_secs)
{
- register const struct state * sp;
- register int dir;
- register int bits;
- register int i, j ;
- register int saved_seconds;
- time_t newt;
- time_t t;
- struct pg_tm yourtm, mytm;
+ register const struct state *sp;
+ register int dir;
+ register int bits;
+ register int i,
+ j;
+ register int saved_seconds;
+ time_t newt;
+ time_t t;
+ struct pg_tm yourtm,
+ mytm;
*okayp = FALSE;
yourtm = *tmp;
- if (do_norm_secs) {
+ if (do_norm_secs)
+ {
if (normalize_overflow(&yourtm.tm_min, &yourtm.tm_sec,
- SECSPERMIN))
- return WRONG;
+ SECSPERMIN))
+ return WRONG;
}
if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR))
return WRONG;
return WRONG;
if (normalize_overflow(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR))
return WRONG;
+
/*
- ** Turn yourtm.tm_year into an actual year number for now.
- ** It is converted back to an offset from TM_YEAR_BASE later.
- */
+ * * Turn yourtm.tm_year into an actual year number for now. * It is
+ * converted back to an offset from TM_YEAR_BASE later.
+ */
if (increment_overflow(&yourtm.tm_year, TM_YEAR_BASE))
return WRONG;
- while (yourtm.tm_mday <= 0) {
+ while (yourtm.tm_mday <= 0)
+ {
if (increment_overflow(&yourtm.tm_year, -1))
return WRONG;
i = yourtm.tm_year + (1 < yourtm.tm_mon);
yourtm.tm_mday += year_lengths[isleap(i)];
}
- while (yourtm.tm_mday > DAYSPERLYEAR) {
+ while (yourtm.tm_mday > DAYSPERLYEAR)
+ {
i = yourtm.tm_year + (1 < yourtm.tm_mon);
yourtm.tm_mday -= year_lengths[isleap(i)];
if (increment_overflow(&yourtm.tm_year, 1))
return WRONG;
}
- for ( ; ; ) {
+ for (;;)
+ {
i = mon_lengths[isleap(yourtm.tm_year)][yourtm.tm_mon];
if (yourtm.tm_mday <= i)
break;
yourtm.tm_mday -= i;
- if (++yourtm.tm_mon >= MONSPERYEAR) {
+ if (++yourtm.tm_mon >= MONSPERYEAR)
+ {
yourtm.tm_mon = 0;
if (increment_overflow(&yourtm.tm_year, 1))
return WRONG;
return WRONG;
if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN)
saved_seconds = 0;
- else if (yourtm.tm_year + TM_YEAR_BASE < EPOCH_YEAR) {
+ else if (yourtm.tm_year + TM_YEAR_BASE < EPOCH_YEAR)
+ {
/*
- ** We can't set tm_sec to 0, because that might push the
- ** time below the minimum representable time.
- ** Set tm_sec to 59 instead.
- ** This assumes that the minimum representable time is
- ** not in the same minute that a leap second was deleted from,
- ** which is a safer assumption than using 58 would be.
- */
+ * * We can't set tm_sec to 0, because that might push the * time
+ * below the minimum representable time. * Set tm_sec to 59
+ * instead. * This assumes that the minimum representable time is *
+ * not in the same minute that a leap second was deleted from, *
+ * which is a safer assumption than using 58 would be.
+ */
if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN))
return WRONG;
saved_seconds = yourtm.tm_sec;
yourtm.tm_sec = SECSPERMIN - 1;
- } else {
+ }
+ else
+ {
saved_seconds = yourtm.tm_sec;
yourtm.tm_sec = 0;
}
+
/*
- ** Divide the search space in half
- ** (this works whether time_t is signed or unsigned).
- */
- bits = TYPE_BIT(time_t) - 1;
+ * * Divide the search space in half * (this works whether time_t is
+ * signed or unsigned).
+ */
+ bits = TYPE_BIT(time_t) -1;
+
/*
- ** If time_t is signed, then 0 is just above the median,
- ** assuming two's complement arithmetic.
- ** If time_t is unsigned, then (1 << bits) is just above the median.
- */
+ * * If time_t is signed, then 0 is just above the median, * assuming
+ * two's complement arithmetic. * If time_t is unsigned, then (1 <<
+ * bits) is just above the median.
+ */
t = TYPE_SIGNED(time_t) ? 0 : (((time_t) 1) << bits);
- for ( ; ; ) {
- (*funcp)(&t, offset, &mytm);
+ for (;;)
+ {
+ (*funcp) (&t, offset, &mytm);
dir = tmcomp(&mytm, &yourtm);
- if (dir != 0) {
+ if (dir != 0)
+ {
if (bits-- < 0)
return WRONG;
if (bits < 0)
- --t; /* may be needed if new t is minimal */
+ --t; /* may be needed if new t is minimal */
else if (dir > 0)
t -= ((time_t) 1) << bits;
- else t += ((time_t) 1) << bits;
+ else
+ t += ((time_t) 1) << bits;
continue;
}
if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
break;
+
/*
- ** Right time, wrong type.
- ** Hunt for right time, right type.
- ** It's okay to guess wrong since the guess
- ** gets checked.
- */
+ * * Right time, wrong type. * Hunt for right time, right type. *
+ * It's okay to guess wrong since the guess * gets checked.
+ */
+
/*
- ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
- */
+ * * The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
+ */
sp = (const struct state *)
(((void *) funcp == (void *) localsub) ?
- lclptr : gmtptr);
- for (i = sp->typecnt - 1; i >= 0; --i) {
+ lclptr : gmtptr);
+ for (i = sp->typecnt - 1; i >= 0; --i)
+ {
if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
continue;
- for (j = sp->typecnt - 1; j >= 0; --j) {
+ for (j = sp->typecnt - 1; j >= 0; --j)
+ {
if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
continue;
newt = t + sp->ttis[j].tt_gmtoff -
sp->ttis[i].tt_gmtoff;
- (*funcp)(&newt, offset, &mytm);
+ (*funcp) (&newt, offset, &mytm);
if (tmcomp(&mytm, &yourtm) != 0)
continue;
if (mytm.tm_isdst != yourtm.tm_isdst)
continue;
+
/*
- ** We have a match.
- */
+ * * We have a match.
+ */
t = newt;
goto label;
}
if ((newt < t) != (saved_seconds < 0))
return WRONG;
t = newt;
- (*funcp)(&t, offset, tmp);
+ (*funcp) (&t, offset, tmp);
*okayp = TRUE;
return t;
}
-static time_t time2(struct pg_tm *tmp, void(*funcp)(const time_t*, long, struct pg_tm*), const long offset, int *okayp)
+static time_t time2(struct pg_tm * tmp, void (*funcp) (const time_t *, long, struct pg_tm *), const long offset, int *okayp)
{
- time_t t;
+ time_t t;
/*
- ** First try without normalization of seconds
- ** (in case tm_sec contains a value associated with a leap second).
- ** If that fails, try with normalization of seconds.
- */
+ * * First try without normalization of seconds * (in case tm_sec
+ * contains a value associated with a leap second). * If that fails,
+ * try with normalization of seconds.
+ */
t = time2sub(tmp, funcp, offset, okayp, FALSE);
return *okayp ? t : time2sub(tmp, funcp, offset, okayp, TRUE);
}
-static time_t time1(struct pg_tm *tmp, void (*funcp)(const time_t *, long, struct pg_tm *), const long offset)
+static time_t time1(struct pg_tm * tmp, void (*funcp) (const time_t *, long, struct pg_tm *), const long offset)
{
- register time_t t;
- register const struct state * sp;
- register int samei, otheri;
- register int sameind, otherind;
- register int i;
- register int nseen;
- int seen[TZ_MAX_TYPES];
- int types[TZ_MAX_TYPES];
- int okay;
+ register time_t t;
+ register const struct state *sp;
+ register int samei,
+ otheri;
+ register int sameind,
+ otherind;
+ register int i;
+ register int nseen;
+ int seen[TZ_MAX_TYPES];
+ int types[TZ_MAX_TYPES];
+ int okay;
if (tmp->tm_isdst > 1)
tmp->tm_isdst = 1;
t = time2(tmp, funcp, offset, &okay);
if (okay || tmp->tm_isdst < 0)
return t;
+
/*
- ** We're supposed to assume that somebody took a time of one type
- ** and did some math on it that yielded a "struct pg_tm" that's bad.
- ** We try to divine the type they started from and adjust to the
- ** type they need.
- */
+ * * We're supposed to assume that somebody took a time of one type *
+ * and did some math on it that yielded a "struct pg_tm" that's bad. *
+ * We try to divine the type they started from and adjust to the *
+ * type they need.
+ */
+
/*
- ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
- */
+ * * The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
+ */
sp = (const struct state *) (((void *) funcp == (void *) localsub) ?
- lclptr : gmtptr);
+ lclptr : gmtptr);
for (i = 0; i < sp->typecnt; ++i)
seen[i] = FALSE;
nseen = 0;
for (i = sp->timecnt - 1; i >= 0; --i)
- if (!seen[sp->types[i]]) {
+ if (!seen[sp->types[i]])
+ {
seen[sp->types[i]] = TRUE;
types[nseen++] = sp->types[i];
}
- for (sameind = 0; sameind < nseen; ++sameind) {
+ for (sameind = 0; sameind < nseen; ++sameind)
+ {
samei = types[sameind];
if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
continue;
- for (otherind = 0; otherind < nseen; ++otherind) {
+ for (otherind = 0; otherind < nseen; ++otherind)
+ {
otheri = types[otherind];
if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
continue;
tmp->tm_sec += sp->ttis[otheri].tt_gmtoff -
- sp->ttis[samei].tt_gmtoff;
+ sp->ttis[samei].tt_gmtoff;
tmp->tm_isdst = !tmp->tm_isdst;
t = time2(tmp, funcp, offset, &okay);
if (okay)
return t;
tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff -
- sp->ttis[samei].tt_gmtoff;
+ sp->ttis[samei].tt_gmtoff;
tmp->tm_isdst = !tmp->tm_isdst;
}
}
return WRONG;
}
-time_t pg_mktime(struct pg_tm *tmp)
+time_t
+pg_mktime(struct pg_tm * tmp)
{
return time1(tmp, localsub, 0L);
}
* Return the name of the current timezone
*/
const char *
-pg_get_current_timezone(void) {
+pg_get_current_timezone(void)
+{
if (lcl_is_set)
return lcl_TZname;
return NULL;
#include "tzfile.h"
-struct lc_time_T {
- const char * mon[MONSPERYEAR];
- const char * month[MONSPERYEAR];
- const char * wday[DAYSPERWEEK];
- const char * weekday[DAYSPERWEEK];
- const char * X_fmt;
- const char * x_fmt;
- const char * c_fmt;
- const char * am;
- const char * pm;
- const char * date_fmt;
+struct lc_time_T
+{
+ const char *mon[MONSPERYEAR];
+ const char *month[MONSPERYEAR];
+ const char *wday[DAYSPERWEEK];
+ const char *weekday[DAYSPERWEEK];
+ const char *X_fmt;
+ const char *x_fmt;
+ const char *c_fmt;
+ const char *am;
+ const char *pm;
+ const char *date_fmt;
};
#define Locale (&C_time_locale)
-static const struct lc_time_T C_time_locale = {
+static const struct lc_time_T C_time_locale = {
{
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
"%H:%M:%S",
/*
- ** x_fmt
- ** C99 requires this format.
- ** Using just numbers (as here) makes Quakers happier;
- ** it's also compatible with SVR4.
- */
+ * * x_fmt * C99 requires this format. * Using just numbers (as here)
+ * makes Quakers happier; * it's also compatible with SVR4.
+ */
"%m/%d/%y",
/*
- ** c_fmt
- ** C99 requires this format.
- ** Previously this code used "%D %X", but we now conform to C99.
- ** Note that
- ** "%a %b %d %H:%M:%S %Y"
- ** is used by Solaris 2.3.
- */
+ * * c_fmt * C99 requires this format. * Previously this code used "%D
+ * %X", but we now conform to C99. * Note that * "%a %b %d
+ * %H:%M:%S %Y" * is used by Solaris 2.3.
+ */
"%a %b %e %T %Y",
/* am */
"%a %b %e %H:%M:%S %Z %Y"
};
-static char * _add (const char *, char *, const char *);
-static char * _conv (int, const char *, char *, const char *);
-static char * _fmt (const char *, const struct pg_tm *, char *, const char *, int *);
+static char *_add(const char *, char *, const char *);
+static char *_conv(int, const char *, char *, const char *);
+static char *_fmt(const char *, const struct pg_tm *, char *, const char *, int *);
-#define IN_NONE 0
-#define IN_SOME 1
-#define IN_THIS 2
+#define IN_NONE 0
+#define IN_SOME 1
+#define IN_THIS 2
#define IN_ALL 3
-size_t pg_strftime(char *s, size_t maxsize, const char *format, const struct pg_tm *t)
+size_t
+pg_strftime(char *s, size_t maxsize, const char *format, const struct pg_tm * t)
{
- char * p;
- int warn;
+ char *p;
+ int warn;
warn = IN_NONE;
p = _fmt(((format == NULL) ? "%c" : format), t, s, s + maxsize, &warn);
return p - s;
}
-static char * _fmt(const char *format, const struct pg_tm *t, char *pt, const char *ptlim, int *warnp)
+static char *
+_fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim, int *warnp)
{
- for ( ; *format; ++format) {
- if (*format == '%') {
-label:
- switch (*++format) {
- case '\0':
- --format;
- break;
- case 'A':
- pt = _add((t->tm_wday < 0 ||
- t->tm_wday >= DAYSPERWEEK) ?
- "?" : Locale->weekday[t->tm_wday],
- pt, ptlim);
- continue;
- case 'a':
- pt = _add((t->tm_wday < 0 ||
- t->tm_wday >= DAYSPERWEEK) ?
- "?" : Locale->wday[t->tm_wday],
- pt, ptlim);
- continue;
- case 'B':
- pt = _add((t->tm_mon < 0 ||
- t->tm_mon >= MONSPERYEAR) ?
- "?" : Locale->month[t->tm_mon],
- pt, ptlim);
- continue;
- case 'b':
- case 'h':
- pt = _add((t->tm_mon < 0 ||
- t->tm_mon >= MONSPERYEAR) ?
- "?" : Locale->mon[t->tm_mon],
- pt, ptlim);
- continue;
- case 'C':
- /*
- ** %C used to do a...
- ** _fmt("%a %b %e %X %Y", t);
- ** ...whereas now POSIX 1003.2 calls for
- ** something completely different.
- ** (ado, 1993-05-24)
- */
- pt = _conv((t->tm_year + TM_YEAR_BASE) / 100,
- "%02d", pt, ptlim);
- continue;
- case 'c':
- {
- int warn2 = IN_SOME;
-
- pt = _fmt(Locale->c_fmt, t, pt, ptlim, warnp);
- if (warn2 == IN_ALL)
- warn2 = IN_THIS;
- if (warn2 > *warnp)
- *warnp = warn2;
- }
- continue;
- case 'D':
- pt = _fmt("%m/%d/%y", t, pt, ptlim, warnp);
- continue;
- case 'd':
- pt = _conv(t->tm_mday, "%02d", pt, ptlim);
- continue;
- case 'E':
- case 'O':
- /*
- ** C99 locale modifiers.
- ** The sequences
- ** %Ec %EC %Ex %EX %Ey %EY
- ** %Od %oe %OH %OI %Om %OM
- ** %OS %Ou %OU %OV %Ow %OW %Oy
- ** are supposed to provide alternate
- ** representations.
- */
- goto label;
- case 'e':
- pt = _conv(t->tm_mday, "%2d", pt, ptlim);
- continue;
- case 'F':
- pt = _fmt("%Y-%m-%d", t, pt, ptlim, warnp);
- continue;
- case 'H':
- pt = _conv(t->tm_hour, "%02d", pt, ptlim);
- continue;
- case 'I':
- pt = _conv((t->tm_hour % 12) ?
- (t->tm_hour % 12) : 12,
- "%02d", pt, ptlim);
- continue;
- case 'j':
- pt = _conv(t->tm_yday + 1, "%03d", pt, ptlim);
- continue;
- case 'k':
- /*
- ** This used to be...
- ** _conv(t->tm_hour % 12 ?
- ** t->tm_hour % 12 : 12, 2, ' ');
- ** ...and has been changed to the below to
- ** match SunOS 4.1.1 and Arnold Robbins'
- ** strftime version 3.0. That is, "%k" and
- ** "%l" have been swapped.
- ** (ado, 1993-05-24)
- */
- pt = _conv(t->tm_hour, "%2d", pt, ptlim);
- continue;
+ for (; *format; ++format)
+ {
+ if (*format == '%')
+ {
+ label:
+ switch (*++format)
+ {
+ case '\0':
+ --format;
+ break;
+ case 'A':
+ pt = _add((t->tm_wday < 0 ||
+ t->tm_wday >= DAYSPERWEEK) ?
+ "?" : Locale->weekday[t->tm_wday],
+ pt, ptlim);
+ continue;
+ case 'a':
+ pt = _add((t->tm_wday < 0 ||
+ t->tm_wday >= DAYSPERWEEK) ?
+ "?" : Locale->wday[t->tm_wday],
+ pt, ptlim);
+ continue;
+ case 'B':
+ pt = _add((t->tm_mon < 0 ||
+ t->tm_mon >= MONSPERYEAR) ?
+ "?" : Locale->month[t->tm_mon],
+ pt, ptlim);
+ continue;
+ case 'b':
+ case 'h':
+ pt = _add((t->tm_mon < 0 ||
+ t->tm_mon >= MONSPERYEAR) ?
+ "?" : Locale->mon[t->tm_mon],
+ pt, ptlim);
+ continue;
+ case 'C':
+
+ /*
+ * * %C used to do a... * _fmt("%a %b %e %X %Y", t); *
+ * ...whereas now POSIX 1003.2 calls for * something
+ * completely different. * (ado, 1993-05-24)
+ */
+ pt = _conv((t->tm_year + TM_YEAR_BASE) / 100,
+ "%02d", pt, ptlim);
+ continue;
+ case 'c':
+ {
+ int warn2 = IN_SOME;
+
+ pt = _fmt(Locale->c_fmt, t, pt, ptlim, warnp);
+ if (warn2 == IN_ALL)
+ warn2 = IN_THIS;
+ if (warn2 > *warnp)
+ *warnp = warn2;
+ }
+ continue;
+ case 'D':
+ pt = _fmt("%m/%d/%y", t, pt, ptlim, warnp);
+ continue;
+ case 'd':
+ pt = _conv(t->tm_mday, "%02d", pt, ptlim);
+ continue;
+ case 'E':
+ case 'O':
+
+ /*
+ * * C99 locale modifiers. * The sequences * %Ec %EC
+ * %Ex %EX %Ey %EY * %Od %oe %OH %OI %Om %OM * %OS
+ * %Ou %OU %OV %Ow %OW %Oy * are supposed to provide
+ * alternate * representations.
+ */
+ goto label;
+ case 'e':
+ pt = _conv(t->tm_mday, "%2d", pt, ptlim);
+ continue;
+ case 'F':
+ pt = _fmt("%Y-%m-%d", t, pt, ptlim, warnp);
+ continue;
+ case 'H':
+ pt = _conv(t->tm_hour, "%02d", pt, ptlim);
+ continue;
+ case 'I':
+ pt = _conv((t->tm_hour % 12) ?
+ (t->tm_hour % 12) : 12,
+ "%02d", pt, ptlim);
+ continue;
+ case 'j':
+ pt = _conv(t->tm_yday + 1, "%03d", pt, ptlim);
+ continue;
+ case 'k':
+
+ /*
+ * * This used to be... * _conv(t->tm_hour % 12 ? *
+ * t->tm_hour % 12 : 12, 2, ' '); * ...and has been
+ * changed to the below to * match SunOS 4.1.1 and
+ * Arnold Robbins' * strftime version 3.0. That is,
+ * "%k" and * "%l" have been swapped. * (ado,
+ * 1993-05-24)
+ */
+ pt = _conv(t->tm_hour, "%2d", pt, ptlim);
+ continue;
#ifdef KITCHEN_SINK
- case 'K':
- /*
- ** After all this time, still unclaimed!
- */
- pt = _add("kitchen sink", pt, ptlim);
- continue;
-#endif /* defined KITCHEN_SINK */
- case 'l':
- /*
- ** This used to be...
- ** _conv(t->tm_hour, 2, ' ');
- ** ...and has been changed to the below to
- ** match SunOS 4.1.1 and Arnold Robbin's
- ** strftime version 3.0. That is, "%k" and
- ** "%l" have been swapped.
- ** (ado, 1993-05-24)
- */
- pt = _conv((t->tm_hour % 12) ?
- (t->tm_hour % 12) : 12,
- "%2d", pt, ptlim);
- continue;
- case 'M':
- pt = _conv(t->tm_min, "%02d", pt, ptlim);
- continue;
- case 'm':
- pt = _conv(t->tm_mon + 1, "%02d", pt, ptlim);
- continue;
- case 'n':
- pt = _add("\n", pt, ptlim);
- continue;
- case 'p':
- pt = _add((t->tm_hour >= (HOURSPERDAY / 2)) ?
- Locale->pm :
- Locale->am,
- pt, ptlim);
- continue;
- case 'R':
- pt = _fmt("%H:%M", t, pt, ptlim, warnp);
- continue;
- case 'r':
- pt = _fmt("%I:%M:%S %p", t, pt, ptlim, warnp);
- continue;
- case 'S':
- pt = _conv(t->tm_sec, "%02d", pt, ptlim);
- continue;
- case 's':
- {
- struct pg_tm tm;
- char buf[INT_STRLEN_MAXIMUM(time_t) + 1];
- time_t mkt;
-
- tm = *t;
- mkt = pg_mktime(&tm);
- if (TYPE_SIGNED(time_t))
- (void) sprintf(buf, "%ld", (long) mkt);
- else
- (void) sprintf(buf, "%lu", (unsigned long) mkt);
- pt = _add(buf, pt, ptlim);
- }
- continue;
- case 'T':
- pt = _fmt("%H:%M:%S", t, pt, ptlim, warnp);
- continue;
- case 't':
- pt = _add("\t", pt, ptlim);
- continue;
- case 'U':
- pt = _conv((t->tm_yday + DAYSPERWEEK -
- t->tm_wday) / DAYSPERWEEK,
- "%02d", pt, ptlim);
- continue;
- case 'u':
- /*
- ** From Arnold Robbins' strftime version 3.0:
- ** "ISO 8601: Weekday as a decimal number
- ** [1 (Monday) - 7]"
- ** (ado, 1993-05-24)
- */
- pt = _conv((t->tm_wday == 0) ?
- DAYSPERWEEK : t->tm_wday,
- "%d", pt, ptlim);
- continue;
- case 'V': /* ISO 8601 week number */
- case 'G': /* ISO 8601 year (four digits) */
- case 'g': /* ISO 8601 year (two digits) */
+ case 'K':
+
+ /*
+ * * After all this time, still unclaimed!
+ */
+ pt = _add("kitchen sink", pt, ptlim);
+ continue;
+#endif /* defined KITCHEN_SINK */
+ case 'l':
+
+ /*
+ * * This used to be... * _conv(t->tm_hour, 2, ' '); *
+ * ...and has been changed to the below to * match
+ * SunOS 4.1.1 and Arnold Robbin's * strftime version
+ * 3.0. That is, "%k" and * "%l" have been swapped. *
+ * (ado, 1993-05-24)
+ */
+ pt = _conv((t->tm_hour % 12) ?
+ (t->tm_hour % 12) : 12,
+ "%2d", pt, ptlim);
+ continue;
+ case 'M':
+ pt = _conv(t->tm_min, "%02d", pt, ptlim);
+ continue;
+ case 'm':
+ pt = _conv(t->tm_mon + 1, "%02d", pt, ptlim);
+ continue;
+ case 'n':
+ pt = _add("\n", pt, ptlim);
+ continue;
+ case 'p':
+ pt = _add((t->tm_hour >= (HOURSPERDAY / 2)) ?
+ Locale->pm :
+ Locale->am,
+ pt, ptlim);
+ continue;
+ case 'R':
+ pt = _fmt("%H:%M", t, pt, ptlim, warnp);
+ continue;
+ case 'r':
+ pt = _fmt("%I:%M:%S %p", t, pt, ptlim, warnp);
+ continue;
+ case 'S':
+ pt = _conv(t->tm_sec, "%02d", pt, ptlim);
+ continue;
+ case 's':
+ {
+ struct pg_tm tm;
+ char buf[INT_STRLEN_MAXIMUM(time_t) +1];
+ time_t mkt;
+
+ tm = *t;
+ mkt = pg_mktime(&tm);
+ if (TYPE_SIGNED(time_t))
+ (void) sprintf(buf, "%ld", (long) mkt);
+ else
+ (void) sprintf(buf, "%lu", (unsigned long) mkt);
+ pt = _add(buf, pt, ptlim);
+ }
+ continue;
+ case 'T':
+ pt = _fmt("%H:%M:%S", t, pt, ptlim, warnp);
+ continue;
+ case 't':
+ pt = _add("\t", pt, ptlim);
+ continue;
+ case 'U':
+ pt = _conv((t->tm_yday + DAYSPERWEEK -
+ t->tm_wday) / DAYSPERWEEK,
+ "%02d", pt, ptlim);
+ continue;
+ case 'u':
+
+ /*
+ * * From Arnold Robbins' strftime version 3.0: * "ISO
+ * 8601: Weekday as a decimal number * [1 (Monday) -
+ * 7]" * (ado, 1993-05-24)
+ */
+ pt = _conv((t->tm_wday == 0) ?
+ DAYSPERWEEK : t->tm_wday,
+ "%d", pt, ptlim);
+ continue;
+ case 'V': /* ISO 8601 week number */
+ case 'G': /* ISO 8601 year (four digits) */
+ case 'g': /* ISO 8601 year (two digits) */
/*
** From Arnold Robbins' strftime version 3.0: "the week number of the
** year (the first Monday as the first day of week 1) as a decimal number
** 1997 lasts from 1996-12-30 to 1997-01-05..."
** (ado, 1996-01-02)
*/
- {
- int year;
- int yday;
- int wday;
- int w;
-
- year = t->tm_year + TM_YEAR_BASE;
- yday = t->tm_yday;
- wday = t->tm_wday;
- for ( ; ; ) {
- int len;
- int bot;
- int top;
-
- len = isleap(year) ?
- DAYSPERLYEAR :
- DAYSPERNYEAR;
- /*
- ** What yday (-3 ... 3) does
- ** the ISO year begin on?
- */
- bot = ((yday + 11 - wday) %
- DAYSPERWEEK) - 3;
- /*
- ** What yday does the NEXT
- ** ISO year begin on?
- */
- top = bot -
- (len % DAYSPERWEEK);
- if (top < -3)
- top += DAYSPERWEEK;
- top += len;
- if (yday >= top) {
- ++year;
- w = 1;
- break;
+ {
+ int year;
+ int yday;
+ int wday;
+ int w;
+
+ year = t->tm_year + TM_YEAR_BASE;
+ yday = t->tm_yday;
+ wday = t->tm_wday;
+ for (;;)
+ {
+ int len;
+ int bot;
+ int top;
+
+ len = isleap(year) ?
+ DAYSPERLYEAR :
+ DAYSPERNYEAR;
+
+ /*
+ * * What yday (-3 ... 3) does * the ISO year
+ * begin on?
+ */
+ bot = ((yday + 11 - wday) %
+ DAYSPERWEEK) - 3;
+
+ /*
+ * * What yday does the NEXT * ISO year begin
+ * on?
+ */
+ top = bot -
+ (len % DAYSPERWEEK);
+ if (top < -3)
+ top += DAYSPERWEEK;
+ top += len;
+ if (yday >= top)
+ {
+ ++year;
+ w = 1;
+ break;
+ }
+ if (yday >= bot)
+ {
+ w = 1 + ((yday - bot) /
+ DAYSPERWEEK);
+ break;
+ }
+ --year;
+ yday += isleap(year) ?
+ DAYSPERLYEAR :
+ DAYSPERNYEAR;
}
- if (yday >= bot) {
- w = 1 + ((yday - bot) /
- DAYSPERWEEK);
- break;
+ if (*format == 'V')
+ pt = _conv(w, "%02d",
+ pt, ptlim);
+ else if (*format == 'g')
+ {
+ *warnp = IN_ALL;
+ pt = _conv(year % 100, "%02d",
+ pt, ptlim);
}
- --year;
- yday += isleap(year) ?
- DAYSPERLYEAR :
- DAYSPERNYEAR;
+ else
+ pt = _conv(year, "%04d",
+ pt, ptlim);
}
- if (*format == 'V')
- pt = _conv(w, "%02d",
- pt, ptlim);
- else if (*format == 'g') {
- *warnp = IN_ALL;
- pt = _conv(year % 100, "%02d",
- pt, ptlim);
- } else pt = _conv(year, "%04d",
- pt, ptlim);
- }
- continue;
- case 'v':
- /*
- ** From Arnold Robbins' strftime version 3.0:
- ** "date as dd-bbb-YYYY"
- ** (ado, 1993-05-24)
- */
- pt = _fmt("%e-%b-%Y", t, pt, ptlim, warnp);
- continue;
- case 'W':
- pt = _conv((t->tm_yday + DAYSPERWEEK -
- (t->tm_wday ?
- (t->tm_wday - 1) :
- (DAYSPERWEEK - 1))) / DAYSPERWEEK,
- "%02d", pt, ptlim);
- continue;
- case 'w':
- pt = _conv(t->tm_wday, "%d", pt, ptlim);
- continue;
- case 'X':
- pt = _fmt(Locale->X_fmt, t, pt, ptlim, warnp);
- continue;
- case 'x':
- {
- int warn2 = IN_SOME;
-
- pt = _fmt(Locale->x_fmt, t, pt, ptlim, &warn2);
- if (warn2 == IN_ALL)
- warn2 = IN_THIS;
- if (warn2 > *warnp)
- *warnp = warn2;
- }
- continue;
- case 'y':
- *warnp = IN_ALL;
- pt = _conv((t->tm_year + TM_YEAR_BASE) % 100,
- "%02d", pt, ptlim);
- continue;
- case 'Y':
- pt = _conv(t->tm_year + TM_YEAR_BASE, "%04d",
- pt, ptlim);
- continue;
- case 'Z':
- if (t->tm_zone != NULL)
- pt = _add(t->tm_zone, pt, ptlim);
- /*
- ** C99 says that %Z must be replaced by the
- ** empty string if the time zone is not
- ** determinable.
- */
- continue;
- case 'z':
- {
- int diff;
- char const * sign;
-
- if (t->tm_isdst < 0)
- continue;
- diff = t->tm_gmtoff;
- if (diff < 0) {
- sign = "-";
- diff = -diff;
- } else sign = "+";
- pt = _add(sign, pt, ptlim);
- diff /= 60;
- pt = _conv((diff/60)*100 + diff%60,
- "%04d", pt, ptlim);
- }
- continue;
- case '+':
- pt = _fmt(Locale->date_fmt, t, pt, ptlim,
- warnp);
- continue;
- case '%':
- /*
- ** X311J/88-090 (4.12.3.5): if conversion char is
- ** undefined, behavior is undefined. Print out the
- ** character itself as printf(3) also does.
- */
- default:
- break;
+ continue;
+ case 'v':
+
+ /*
+ * * From Arnold Robbins' strftime version 3.0: *
+ * "date as dd-bbb-YYYY" * (ado, 1993-05-24)
+ */
+ pt = _fmt("%e-%b-%Y", t, pt, ptlim, warnp);
+ continue;
+ case 'W':
+ pt = _conv((t->tm_yday + DAYSPERWEEK -
+ (t->tm_wday ?
+ (t->tm_wday - 1) :
+ (DAYSPERWEEK - 1))) / DAYSPERWEEK,
+ "%02d", pt, ptlim);
+ continue;
+ case 'w':
+ pt = _conv(t->tm_wday, "%d", pt, ptlim);
+ continue;
+ case 'X':
+ pt = _fmt(Locale->X_fmt, t, pt, ptlim, warnp);
+ continue;
+ case 'x':
+ {
+ int warn2 = IN_SOME;
+
+ pt = _fmt(Locale->x_fmt, t, pt, ptlim, &warn2);
+ if (warn2 == IN_ALL)
+ warn2 = IN_THIS;
+ if (warn2 > *warnp)
+ *warnp = warn2;
+ }
+ continue;
+ case 'y':
+ *warnp = IN_ALL;
+ pt = _conv((t->tm_year + TM_YEAR_BASE) % 100,
+ "%02d", pt, ptlim);
+ continue;
+ case 'Y':
+ pt = _conv(t->tm_year + TM_YEAR_BASE, "%04d",
+ pt, ptlim);
+ continue;
+ case 'Z':
+ if (t->tm_zone != NULL)
+ pt = _add(t->tm_zone, pt, ptlim);
+
+ /*
+ * * C99 says that %Z must be replaced by the * empty
+ * string if the time zone is not * determinable.
+ */
+ continue;
+ case 'z':
+ {
+ int diff;
+ char const *sign;
+
+ if (t->tm_isdst < 0)
+ continue;
+ diff = t->tm_gmtoff;
+ if (diff < 0)
+ {
+ sign = "-";
+ diff = -diff;
+ }
+ else
+ sign = "+";
+ pt = _add(sign, pt, ptlim);
+ diff /= 60;
+ pt = _conv((diff / 60) * 100 + diff % 60,
+ "%04d", pt, ptlim);
+ }
+ continue;
+ case '+':
+ pt = _fmt(Locale->date_fmt, t, pt, ptlim,
+ warnp);
+ continue;
+ case '%':
+
+ /*
+ * * X311J/88-090 (4.12.3.5): if conversion char is *
+ * undefined, behavior is undefined. Print out the *
+ * character itself as printf(3) also does.
+ */
+ default:
+ break;
}
}
if (pt == ptlim)
return pt;
}
-static char * _conv(const int n, const char *format, char *pt, const char *ptlim)
+static char *
+_conv(const int n, const char *format, char *pt, const char *ptlim)
{
- char buf[INT_STRLEN_MAXIMUM(int) + 1];
+ char buf[INT_STRLEN_MAXIMUM(int) +1];
(void) sprintf(buf, format, n);
return _add(buf, pt, ptlim);
}
-static char *_add(const char *str, char *pt, const char *ptlim)
+static char *
+_add(const char *str, char *pt, const char *ptlim)
{
while (pt < ptlim && (*pt = *str++) != '\0')
++pt;
#endif
#endif
-static char elsieid[] = "@(#)zic.c 7.115";
+static char elsieid[] = "@(#)zic.c 7.115";
/*
** On some ancient hosts, predicates like `isspace(C)' are defined
-** only if isascii(C) || C == EOF. Modern hosts obey the C Standard,
+** only if isascii(C) || C == EOF. Modern hosts obey the C Standard,
** which says they are defined only if C == ((unsigned char) C) || C == EOF.
** Neither the C Standard nor Posix require that `isascii' exist.
** For portability, we check both ancient and modern requirements.
#define isascii(x) 1
#endif
-struct rule {
- const char * r_filename;
- int r_linenum;
- const char * r_name;
-
- int r_loyear; /* for example, 1986 */
- int r_hiyear; /* for example, 1986 */
- const char * r_yrtype;
-
- int r_month; /* 0..11 */
-
- int r_dycode; /* see below */
- int r_dayofmonth;
- int r_wday;
-
- long r_tod; /* time from midnight */
- int r_todisstd; /* above is standard time if TRUE */
- /* or wall clock time if FALSE */
- 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 */
-
- int r_todo; /* a rule to do (used in outzone) */
- time_t r_temp; /* used in outzone */
+struct rule
+{
+ const char *r_filename;
+ int r_linenum;
+ const char *r_name;
+
+ int r_loyear; /* for example, 1986 */
+ int r_hiyear; /* for example, 1986 */
+ const char *r_yrtype;
+
+ int r_month; /* 0..11 */
+
+ int r_dycode; /* see below */
+ int r_dayofmonth;
+ int r_wday;
+
+ long r_tod; /* time from midnight */
+ int r_todisstd; /* above is standard time if TRUE */
+ /* or wall clock time if FALSE */
+ 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 */
+
+ int r_todo; /* a rule to do (used in outzone) */
+ time_t r_temp; /* used in outzone */
};
/*
** r_dycode r_dayofmonth r_wday
*/
-#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 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) */
-struct zone {
- const char * z_filename;
- int z_linenum;
+struct zone
+{
+ 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;
- int z_nrules;
+ struct rule *z_rules;
+ int z_nrules;
- struct rule z_untilrule;
+ struct rule z_untilrule;
time_t z_untiltime;
};
-extern int link (const char * fromname, const char * toname);
-static void addtt (time_t starttime, int type);
-static int addtype (long gmtoff, const char * abbr, int isdst,
- int ttisstd, int ttisgmt);
-static void leapadd (time_t t, int positive, int rolling, int count);
-static void adjleap (void);
-static void associate (void);
-static int ciequal (const char * ap, const char * bp);
-static void convert (long val, char * buf);
-static void dolink (const char * fromfile, const char * tofile);
-static void doabbr (char * abbr, const char * format,
- const char * letters, int isdst);
-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 int itsabbr (const char * abbr, const char * word);
-static int itsdir (const char * name);
-static int lowerit (int c);
-static char * memcheck (char * tocheck);
-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 int rcomp (const void * leftp, const void * rightp);
-static time_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 void setboundaries (void);
-static time_t tadd (time_t t1, long t2);
-static void usage (void);
-static void writezone (const char * name);
-static int yearistype (int year, const char * type);
+extern int link(const char *fromname, const char *toname);
+static void addtt(time_t starttime, int type);
+static int addtype(long gmtoff, const char *abbr, int isdst,
+ int ttisstd, int ttisgmt);
+static void leapadd(time_t t, int positive, int rolling, int count);
+static void adjleap(void);
+static void associate(void);
+static int ciequal(const char *ap, const char *bp);
+static void convert(long val, char *buf);
+static void dolink(const char *fromfile, const char *tofile);
+static void doabbr(char *abbr, const char *format,
+ const char *letters, int isdst);
+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 int itsabbr(const char *abbr, const char *word);
+static int itsdir(const char *name);
+static int lowerit(int c);
+static char *memcheck(char *tocheck);
+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 int rcomp(const void *leftp, const void *rightp);
+static time_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 void setboundaries(void);
+static time_t tadd(time_t t1, long t2);
+static void usage(void);
+static void writezone(const char *name);
+static int yearistype(int year, const char *type);
#ifndef HAVE_STRERROR
-static char * strerror (int);
+static char *strerror(int);
#endif
-static int charcnt;
-static int errors;
-static const char * filename;
-static int leapcnt;
-static int linenum;
-static time_t max_time;
-static int max_year;
-static int max_year_representable;
-static time_t min_time;
-static int min_year;
-static int min_year_representable;
-static int noise;
-static const char * rfilename;
-static int rlinenum;
-static const char * progname;
-static int timecnt;
-static int typecnt;
+static int charcnt;
+static int errors;
+static const char *filename;
+static int leapcnt;
+static int linenum;
+static time_t max_time;
+static int max_year;
+static int max_year_representable;
+static time_t min_time;
+static int min_year;
+static int min_year_representable;
+static int noise;
+static const char *rfilename;
+static int rlinenum;
+static const char *progname;
+static int timecnt;
+static int typecnt;
/*
** Line codes.
#define ZF_RULE 3
#define ZF_FORMAT 4
#define ZF_TILYEAR 5
-#define ZF_TILMONTH 6
+#define ZF_TILMONTH 6
#define ZF_TILDAY 7
#define ZF_TILTIME 8
#define ZONE_MINFIELDS 5
#define ZFC_GMTOFF 0
#define ZFC_RULE 1
#define ZFC_FORMAT 2
-#define ZFC_TILYEAR 3
+#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 ZFC_TILTIME 6
+#define ZONEC_MINFIELDS 3
+#define ZONEC_MAXFIELDS 7
/*
** Which files are which on a Rule line.
#define RF_TOD 7
#define RF_STDOFF 8
#define RF_ABBRVAR 9
-#define RULE_FIELDS 10
+#define RULE_FIELDS 10
/*
** Which fields are which on a Link line.
#define LF_FROM 1
#define LF_TO 2
-#define LINK_FIELDS 3
+#define LINK_FIELDS 3
/*
** Which fields are which on a Leap line.
#define LP_TIME 4
#define LP_CORR 5
#define LP_ROLL 6
-#define LEAP_FIELDS 7
+#define LEAP_FIELDS 7
/*
** Year synonyms.
#define YR_MAXIMUM 1
#define YR_ONLY 2
-static struct rule * rules;
-static int nrules; /* number of rules */
+static struct rule *rules;
+static int nrules; /* number of rules */
-static struct zone * zones;
-static int nzones; /* number of zones */
+static struct zone *zones;
+static int nzones; /* number of zones */
-struct link {
- const char * l_filename;
- int l_linenum;
- const char * l_from;
- const char * l_to;
+struct link
+{
+ const char *l_filename;
+ int l_linenum;
+ const char *l_from;
+ const char *l_to;
};
-static struct link * links;
-static int nlinks;
+static struct link *links;
+static int nlinks;
-struct lookup {
- const char * l_word;
+struct lookup
+{
+ 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 },
- { "Zone", LC_ZONE },
- { "Link", LC_LINK },
- { "Leap", LC_LEAP },
- { NULL, 0}
+static struct lookup const line_codes[] = {
+ {"Rule", LC_RULE},
+ {"Zone", LC_ZONE},
+ {"Link", LC_LINK},
+ {"Leap", LC_LEAP},
+ {NULL, 0}
};
-static struct lookup const mon_names[] = {
- { "January", TM_JANUARY },
- { "February", TM_FEBRUARY },
- { "March", TM_MARCH },
- { "April", TM_APRIL },
- { "May", TM_MAY },
- { "June", TM_JUNE },
- { "July", TM_JULY },
- { "August", TM_AUGUST },
- { "September", TM_SEPTEMBER },
- { "October", TM_OCTOBER },
- { "November", TM_NOVEMBER },
- { "December", TM_DECEMBER },
- { NULL, 0 }
+static struct lookup const mon_names[] = {
+ {"January", TM_JANUARY},
+ {"February", TM_FEBRUARY},
+ {"March", TM_MARCH},
+ {"April", TM_APRIL},
+ {"May", TM_MAY},
+ {"June", TM_JUNE},
+ {"July", TM_JULY},
+ {"August", TM_AUGUST},
+ {"September", TM_SEPTEMBER},
+ {"October", TM_OCTOBER},
+ {"November", TM_NOVEMBER},
+ {"December", TM_DECEMBER},
+ {NULL, 0}
};
-static struct lookup const wday_names[] = {
- { "Sunday", TM_SUNDAY },
- { "Monday", TM_MONDAY },
- { "Tuesday", TM_TUESDAY },
- { "Wednesday", TM_WEDNESDAY },
- { "Thursday", TM_THURSDAY },
- { "Friday", TM_FRIDAY },
- { "Saturday", TM_SATURDAY },
- { NULL, 0 }
+static struct lookup const wday_names[] = {
+ {"Sunday", TM_SUNDAY},
+ {"Monday", TM_MONDAY},
+ {"Tuesday", TM_TUESDAY},
+ {"Wednesday", TM_WEDNESDAY},
+ {"Thursday", TM_THURSDAY},
+ {"Friday", TM_FRIDAY},
+ {"Saturday", TM_SATURDAY},
+ {NULL, 0}
};
-static struct lookup const lasts[] = {
- { "last-Sunday", TM_SUNDAY },
- { "last-Monday", TM_MONDAY },
- { "last-Tuesday", TM_TUESDAY },
- { "last-Wednesday", TM_WEDNESDAY },
- { "last-Thursday", TM_THURSDAY },
- { "last-Friday", TM_FRIDAY },
- { "last-Saturday", TM_SATURDAY },
- { NULL, 0 }
+static struct lookup const lasts[] = {
+ {"last-Sunday", TM_SUNDAY},
+ {"last-Monday", TM_MONDAY},
+ {"last-Tuesday", TM_TUESDAY},
+ {"last-Wednesday", TM_WEDNESDAY},
+ {"last-Thursday", TM_THURSDAY},
+ {"last-Friday", TM_FRIDAY},
+ {"last-Saturday", TM_SATURDAY},
+ {NULL, 0}
};
-static struct lookup const begin_years[] = {
- { "minimum", YR_MINIMUM },
- { "maximum", YR_MAXIMUM },
- { NULL, 0 }
+static struct lookup const begin_years[] = {
+ {"minimum", YR_MINIMUM},
+ {"maximum", YR_MAXIMUM},
+ {NULL, 0}
};
-static struct lookup const end_years[] = {
- { "minimum", YR_MINIMUM },
- { "maximum", YR_MAXIMUM },
- { "only", YR_ONLY },
- { NULL, 0 }
+static struct lookup const end_years[] = {
+ {"minimum", YR_MINIMUM},
+ {"maximum", YR_MAXIMUM},
+ {"only", YR_ONLY},
+ {NULL, 0}
};
-static struct lookup const leap_types[] = {
- { "Rolling", TRUE },
- { "Stationary", FALSE },
- { NULL, 0 }
+static struct lookup const leap_types[] = {
+ {"Rolling", TRUE},
+ {"Stationary", FALSE},
+ {NULL, 0}
};
-static const int len_months[2][MONSPERYEAR] = {
- { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
- { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
+static const int len_months[2][MONSPERYEAR] = {
+ {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+ {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
-static const int len_years[2] = {
+static const int len_years[2] = {
DAYSPERNYEAR, DAYSPERLYEAR
};
-static struct attype {
+static struct attype
+{
time_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 char ttisstds[TZ_MAX_TYPES];
-static char ttisgmts[TZ_MAX_TYPES];
-static char chars[TZ_MAX_CHARS];
-static time_t trans[TZ_MAX_LEAPS];
-static long corr[TZ_MAX_LEAPS];
-static char roll[TZ_MAX_LEAPS];
+ 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 char ttisstds[TZ_MAX_TYPES];
+static char ttisgmts[TZ_MAX_TYPES];
+static char chars[TZ_MAX_CHARS];
+static time_t trans[TZ_MAX_LEAPS];
+static long corr[TZ_MAX_LEAPS];
+static char roll[TZ_MAX_LEAPS];
/*
** Memory allocation.
static char *
memcheck(ptr)
-char * const ptr;
+char *const ptr;
{
- if (ptr == NULL) {
+ if (ptr == NULL)
+ {
const char *e = strerror(errno);
(void) fprintf(stderr, _("%s: Memory exhausted: %s\n"),
- progname, e);
+ progname, e);
(void) exit(EXIT_FAILURE);
}
return ptr;
}
#define emalloc(size) memcheck(imalloc(size))
-#define erealloc(ptr, size) memcheck(irealloc((ptr), (size)))
+#define erealloc(ptr, size) memcheck(irealloc((ptr), (size)))
#define ecpyalloc(ptr) memcheck(icpyalloc(ptr))
#define ecatalloc(oldp, newp) memcheck(icatalloc((oldp), (newp)))
*/
#ifndef HAVE_STRERROR
-static char *strerror(int errnum)
+static char *
+strerror(int errnum)
{
- extern char * sys_errlist[];
+ extern char *sys_errlist[];
extern int sys_nerr;
return (errnum > 0 && errnum <= sys_nerr) ?
}
#endif
-static void eats(const char *name, const int num, const char *rname, const int rnum)
+static void
+eats(const char *name, const int num, const char *rname, const int rnum)
{
filename = name;
linenum = num;
rlinenum = rnum;
}
-static void eat(const char *name, const int num)
+static void
+eat(const char *name, const int num)
{
eats(name, num, (char *) NULL, -1);
}
-static void error(const char *string)
+static void
+error(const char *string)
{
/*
- ** Match the format of "cc" to allow sh users to
- ** zic ... 2>&1 | error -t "*" -v
- ** on BSD systems.
- */
+ * * Match the format of "cc" to allow sh users to * zic ... 2>&1 |
+ * error -t "*" -v * on BSD systems.
+ */
(void) fprintf(stderr, _("\"%s\", line %d: %s"),
- filename, linenum, string);
+ filename, linenum, string);
if (rfilename != NULL)
(void) fprintf(stderr, _(" (rule from \"%s\", line %d)"),
- rfilename, rlinenum);
+ rfilename, rlinenum);
(void) fprintf(stderr, "\n");
++errors;
}
-static void warning(const char *string)
+static void
+warning(const char *string)
{
- char * cp;
+ char *cp;
cp = ecpyalloc(_("warning: "));
cp = ecatalloc(cp, string);
--errors;
}
-static void usage(void)
+static void
+usage(void)
{
(void) fprintf(stderr, _("%s: usage is %s [ --version ] [ -s ] [ -v ] [ -l localtime ] [ -p posixrules ] \\\n\t[ -d directory ] [ -L leapseconds ] [ -y yearistype ] [ filename ... ]\n"),
- progname, progname);
+ progname, progname);
(void) exit(EXIT_FAILURE);
}
-static const char * psxrules;
-static const char * lcltime;
-static const char * directory;
-static const char * leapsec;
-static const char * yitcommand;
-static int sflag = FALSE;
+static const char *psxrules;
+static const char *lcltime;
+static const char *directory;
+static const char *leapsec;
+static const char *yitcommand;
+static int sflag = FALSE;
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
{
- register int i;
- register int j;
- register int c;
+ register int i;
+ register int j;
+ register int c;
#ifndef WIN32
(void) umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
-#endif /* !WIN32 */
+#endif /* !WIN32 */
progname = argv[0];
for (i = 1; i < argc; ++i)
- if (strcmp(argv[i], "--version") == 0) {
+ if (strcmp(argv[i], "--version") == 0)
+ {
(void) printf("%s\n", elsieid);
(void) exit(EXIT_SUCCESS);
}
while ((c = getopt(argc, argv, "d:l:p:L:vsy:")) != EOF && c != -1)
- switch (c) {
+ switch (c)
+ {
default:
usage();
case 'd':
if (directory == NULL)
directory = optarg;
- else {
+ else
+ {
(void) fprintf(stderr,
-_("%s: More than one -d option specified\n"),
- progname);
+ _("%s: More than one -d option specified\n"),
+ progname);
(void) exit(EXIT_FAILURE);
}
break;
case 'l':
if (lcltime == NULL)
lcltime = optarg;
- else {
+ else
+ {
(void) fprintf(stderr,
-_("%s: More than one -l option specified\n"),
- progname);
+ _("%s: More than one -l option specified\n"),
+ progname);
(void) exit(EXIT_FAILURE);
}
break;
case 'p':
if (psxrules == NULL)
psxrules = optarg;
- else {
+ else
+ {
(void) fprintf(stderr,
-_("%s: More than one -p option specified\n"),
- progname);
+ _("%s: More than one -p option specified\n"),
+ progname);
(void) exit(EXIT_FAILURE);
}
break;
case 'y':
if (yitcommand == NULL)
yitcommand = optarg;
- else {
+ else
+ {
(void) fprintf(stderr,
-_("%s: More than one -y option specified\n"),
- progname);
+ _("%s: More than one -y option specified\n"),
+ progname);
(void) exit(EXIT_FAILURE);
}
break;
case 'L':
if (leapsec == NULL)
leapsec = optarg;
- else {
+ else
+ {
(void) fprintf(stderr,
-_("%s: More than one -L option specified\n"),
- progname);
+ _("%s: More than one -L option specified\n"),
+ progname);
(void) exit(EXIT_FAILURE);
}
break;
break;
}
if (optind == argc - 1 && strcmp(argv[optind], "=") == 0)
- usage(); /* usage message by request */
+ usage(); /* usage message by request */
if (directory == NULL)
directory = "data";
if (yitcommand == NULL)
setboundaries();
- if (optind < argc && leapsec != NULL) {
+ if (optind < argc && leapsec != NULL)
+ {
infile(leapsec);
adjleap();
}
if (errors)
(void) exit(EXIT_FAILURE);
associate();
- for (i = 0; i < nzones; i = j) {
+ for (i = 0; i < nzones; i = j)
+ {
/*
- ** Find the next non-continuation zone entry.
- */
+ * * 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) {
+ * * 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);
}
- if (lcltime != NULL) {
+ if (lcltime != NULL)
+ {
eat("command line", 1);
dolink(lcltime, TZDEFAULT);
}
- if (psxrules != NULL) {
+ if (psxrules != NULL)
+ {
eat("command line", 1);
dolink(psxrules, TZDEFRULES);
}
return (errors == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
-static void dolink(const char *fromfile, const char *tofile)
+static void
+dolink(const char *fromfile, const char *tofile)
{
- register char * fromname;
- register char * toname;
+ register char *fromname;
+ register char *toname;
if (fromfile[0] == '/')
fromname = ecpyalloc(fromfile);
- else {
+ else
+ {
fromname = ecpyalloc(directory);
fromname = ecatalloc(fromname, "/");
fromname = ecatalloc(fromname, fromfile);
}
if (tofile[0] == '/')
toname = ecpyalloc(tofile);
- else {
+ else
+ {
toname = ecpyalloc(directory);
toname = ecatalloc(toname, "/");
toname = ecatalloc(toname, tofile);
}
+
/*
- ** We get to be careful here since
- ** there's a fair chance of root running us.
- */
+ * * We get to be careful here since * there's a fair chance of root
+ * running us.
+ */
if (!itsdir(toname))
(void) remove(toname);
- if (link(fromname, toname) != 0) {
- int result;
+ if (link(fromname, toname) != 0)
+ {
+ int result;
if (mkdirs(toname) != 0)
(void) exit(EXIT_FAILURE);
result = link(fromname, toname);
#ifdef HAVE_SYMLINK
if (result != 0 &&
- access(fromname, F_OK) == 0 &&
- !itsdir(fromname)) {
- const char *s = tofile;
- register char * symlinkcontents = NULL;
- while ((s = strchr(s+1, '/')) != NULL)
- symlinkcontents = ecatalloc(symlinkcontents, "../");
+ access(fromname, F_OK) == 0 &&
+ !itsdir(fromname))
+ {
+ const char *s = tofile;
+ register char *symlinkcontents = NULL;
+
+ while ((s = strchr(s + 1, '/')) != NULL)
+ symlinkcontents = ecatalloc(symlinkcontents, "../");
symlinkcontents = ecatalloc(symlinkcontents, fromfile);
result = symlink(symlinkcontents, toname);
if (result == 0)
-warning(_("hard link failed, symbolic link used"));
+ warning(_("hard link failed, symbolic link used"));
ifree(symlinkcontents);
}
#endif
- if (result != 0) {
+ if (result != 0)
+ {
const char *e = strerror(errno);
(void) fprintf(stderr,
- _("%s: Can't link from %s to %s: %s\n"),
- progname, fromname, toname, e);
+ _("%s: Can't link from %s to %s: %s\n"),
+ progname, fromname, toname, e);
(void) exit(EXIT_FAILURE);
}
}
}
#ifndef INT_MAX
-#define INT_MAX ((int) (((unsigned)~0)>>1))
-#endif /* !defined INT_MAX */
+#define INT_MAX ((int) (((unsigned)~0)>>1))
+#endif /* !defined INT_MAX */
#ifndef INT_MIN
-#define INT_MIN ((int) ~(((unsigned)~0)>>1))
-#endif /* !defined INT_MIN */
+#define INT_MIN ((int) ~(((unsigned)~0)>>1))
+#endif /* !defined INT_MIN */
/*
** The tz file format currently allows at most 32-bit quantities.
*/
#define MAX_BITS_IN_FILE 32
-#define TIME_T_BITS_IN_FILE ((TYPE_BIT(time_t) < MAX_BITS_IN_FILE) ? TYPE_BIT(time_t) : MAX_BITS_IN_FILE)
+#define TIME_T_BITS_IN_FILE ((TYPE_BIT(time_t) < MAX_BITS_IN_FILE) ? TYPE_BIT(time_t) : MAX_BITS_IN_FILE)
-static void setboundaries(void)
+static void
+setboundaries(void)
{
- if (TYPE_SIGNED(time_t)) {
- min_time = ~ (time_t) 0;
+ if (TYPE_SIGNED(time_t))
+ {
+ min_time = ~(time_t) 0;
min_time <<= TIME_T_BITS_IN_FILE - 1;
- max_time = ~ (time_t) 0 - min_time;
+ max_time = ~(time_t) 0 - min_time;
if (sflag)
min_time = 0;
- } else {
+ }
+ else
+ {
min_time = 0;
max_time = 2 - sflag;
max_time <<= TIME_T_BITS_IN_FILE - 1;
max_year_representable = max_year;
}
-static int itsdir(const char *name)
+static int
+itsdir(const char *name)
{
- register char * myname;
- register int accres;
+ register char *myname;
+ register int accres;
myname = ecpyalloc(name);
myname = ecatalloc(myname, "/.");
** Sort by rule name.
*/
-static int rcomp(const void *cp1, const void *cp2)
+static int
+rcomp(const void *cp1, const void *cp2)
{
return strcmp(((const struct rule *) cp1)->r_name,
- ((const struct rule *) cp2)->r_name);
+ ((const struct rule *) cp2)->r_name);
}
-static void associate(void)
+static void
+associate(void)
{
- register struct zone * zp;
- register struct rule * rp;
- register int base, out;
- register int i, j;
-
- if (nrules != 0) {
+ register struct zone *zp;
+ register struct rule *rp;
+ register int base,
+ out;
+ register int i,
+ j;
+
+ if (nrules != 0)
+ {
(void) qsort((void *) rules, (size_t) nrules,
- (size_t) sizeof *rules, rcomp);
- for (i = 0; i < nrules - 1; ++i) {
+ (size_t) sizeof *rules, rcomp);
+ for (i = 0; i < nrules - 1; ++i)
+ {
if (strcmp(rules[i].r_name,
- rules[i + 1].r_name) != 0)
- continue;
+ rules[i + 1].r_name) != 0)
+ continue;
if (strcmp(rules[i].r_filename,
- rules[i + 1].r_filename) == 0)
- continue;
+ 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) {
+ for (j = i + 2; j < nrules; ++j)
+ {
if (strcmp(rules[i].r_name,
- rules[j].r_name) != 0)
- break;
+ rules[j].r_name) != 0)
+ break;
if (strcmp(rules[i].r_filename,
- rules[j].r_filename) == 0)
- continue;
+ rules[j].r_filename) == 0)
+ continue;
if (strcmp(rules[i + 1].r_filename,
- rules[j].r_filename) == 0)
- continue;
+ rules[j].r_filename) == 0)
+ continue;
break;
}
i = j - 1;
}
}
- for (i = 0; i < nzones; ++i) {
+ for (i = 0; i < nzones; ++i)
+ {
zp = &zones[i];
zp->z_rules = NULL;
zp->z_nrules = 0;
}
- for (base = 0; base < nrules; base = out) {
+ 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) {
+ for (i = 0; i < nzones; ++i)
+ {
zp = &zones[i];
if (strcmp(zp->z_rule, rp->r_name) != 0)
continue;
zp->z_nrules = out - base;
}
}
- for (i = 0; i < nzones; ++i) {
+ for (i = 0; i < nzones; ++i)
+ {
zp = &zones[i];
- if (zp->z_nrules == 0) {
+ if (zp->z_nrules == 0)
+ {
/*
- ** Maybe we have a local standard time offset.
- */
+ * * Maybe we have a local standard time offset.
+ */
eat(zp->z_filename, zp->z_linenum);
zp->z_stdoff = gethms(zp->z_rule, _("unruly zone"),
- TRUE);
+ TRUE);
+
/*
- ** Note, though, that if there's no rule,
- ** a '%s' in the format is a bad thing.
- */
+ * * 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"));
}
(void) exit(EXIT_FAILURE);
}
-static void infile(const char *name)
+static void
+infile(const char *name)
{
- register FILE * fp;
- register char ** fields;
- register char * cp;
- register const struct lookup * lp;
- register int nfields;
- register int wantcont;
- register int num;
- char buf[BUFSIZ];
-
- if (strcmp(name, "-") == 0) {
+ register FILE *fp;
+ register char **fields;
+ register char *cp;
+ register const struct lookup *lp;
+ register int nfields;
+ register int wantcont;
+ register int num;
+ char buf[BUFSIZ];
+
+ if (strcmp(name, "-") == 0)
+ {
name = _("standard input");
fp = stdin;
- } else if ((fp = fopen(name, "r")) == NULL) {
+ }
+ else if ((fp = fopen(name, "r")) == NULL)
+ {
const char *e = strerror(errno);
(void) fprintf(stderr, _("%s: Can't open %s: %s\n"),
- progname, name, e);
+ progname, name, e);
(void) exit(EXIT_FAILURE);
}
wantcont = FALSE;
- for (num = 1; ; ++num) {
+ for (num = 1;; ++num)
+ {
eat(name, num);
if (fgets(buf, (int) sizeof buf, fp) != buf)
break;
cp = strchr(buf, '\n');
- if (cp == NULL) {
+ if (cp == NULL)
+ {
error(_("line too long"));
(void) exit(EXIT_FAILURE);
}
*cp = '\0';
fields = getfields(buf);
nfields = 0;
- while (fields[nfields] != NULL) {
- static char nada;
+ while (fields[nfields] != NULL)
+ {
+ static char nada;
if (strcmp(fields[nfields], "-") == 0)
fields[nfields] = &nada;
++nfields;
}
- if (nfields == 0) {
+ if (nfields == 0)
+ {
/* nothing to do */
- } else if (wantcont) {
+ }
+ else if (wantcont)
wantcont = inzcont(fields, nfields);
- } else {
+ else
+ {
lp = byword(fields[0], line_codes);
if (lp == NULL)
error(_("input line of unknown type"));
- else switch ((int) (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:
- if (name != leapsec)
+ else
+ switch ((int) (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:
+ if (name != leapsec)
+ (void) fprintf(stderr,
+ _("%s: Leap line in non leap seconds file %s\n"),
+ progname, name);
+ else
+ inleap(fields, nfields);
+ wantcont = FALSE;
+ break;
+ default: /* "cannot happen" */
(void) fprintf(stderr,
-_("%s: Leap line in non leap seconds file %s\n"),
- progname, name);
- else inleap(fields, nfields);
- wantcont = FALSE;
- break;
- default: /* "cannot happen" */
- (void) fprintf(stderr,
-_("%s: panic: Invalid l_value %d\n"),
- progname, lp->l_value);
- (void) exit(EXIT_FAILURE);
- }
+ _("%s: panic: Invalid l_value %d\n"),
+ progname, lp->l_value);
+ (void) exit(EXIT_FAILURE);
+ }
}
ifree((char *) fields);
}
- if (ferror(fp)) {
+ if (ferror(fp))
+ {
(void) fprintf(stderr, _("%s: Error reading %s\n"),
- progname, filename);
+ progname, filename);
(void) exit(EXIT_FAILURE);
}
- if (fp != stdin && fclose(fp)) {
+ if (fp != stdin && fclose(fp))
+ {
const char *e = strerror(errno);
(void) fprintf(stderr, _("%s: Error closing %s: %s\n"),
- progname, filename, e);
+ progname, filename, e);
(void) exit(EXIT_FAILURE);
}
if (wantcont)
** Call error with errstring and return zero on errors.
*/
-static long gethms(const char *string, const char *errstring, const int signable)
+static long
+gethms(const char *string, const char *errstring, const int signable)
{
- int hh, mm, ss, sign;
+ int hh,
+ mm,
+ ss,
+ sign;
if (string == NULL || *string == '\0')
return 0;
if (!signable)
sign = 1;
- else if (*string == '-') {
+ else if (*string == '-')
+ {
sign = -1;
++string;
- } else sign = 1;
+ }
+ else
+ sign = 1;
if (sscanf(string, scheck(string, "%d"), &hh) == 1)
mm = ss = 0;
else if (sscanf(string, scheck(string, "%d:%d"), &hh, &mm) == 2)
ss = 0;
else if (sscanf(string, scheck(string, "%d:%d:%d"),
- &hh, &mm, &ss) != 3) {
- error(errstring);
- return 0;
+ &hh, &mm, &ss) != 3)
+ {
+ error(errstring);
+ return 0;
}
if ((hh < 0 || hh >= HOURSPERDAY ||
- mm < 0 || mm >= MINSPERHOUR ||
- ss < 0 || ss > SECSPERMIN) &&
- !(hh == HOURSPERDAY && mm == 0 && ss == 0)) {
- error(errstring);
- return 0;
+ mm < 0 || mm >= MINSPERHOUR ||
+ ss < 0 || ss > SECSPERMIN) &&
+ !(hh == HOURSPERDAY && mm == 0 && ss == 0))
+ {
+ error(errstring);
+ return 0;
}
if (noise && hh == HOURSPERDAY)
warning(_("24:00 not handled by pre-1998 versions of zic"));
return eitol(sign) *
(eitol(hh * MINSPERHOUR + mm) *
- eitol(SECSPERMIN) + eitol(ss));
+ eitol(SECSPERMIN) + eitol(ss));
}
-static void inrule(register char **fields, const int nfields)
+static void
+inrule(register char **fields, const int nfields)
{
- static struct rule r;
+ static struct rule r;
- if (nfields != RULE_FIELDS) {
+ if (nfields != RULE_FIELDS)
+ {
error(_("wrong number of fields on Rule line"));
return;
}
- if (*fields[RF_NAME] == '\0') {
+ if (*fields[RF_NAME] == '\0')
+ {
error(_("nameless rule"));
return;
}
r.r_linenum = linenum;
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]);
+ fields[RF_MONTH], fields[RF_DAY], fields[RF_TOD]);
r.r_name = ecpyalloc(fields[RF_NAME]);
r.r_abbrvar = ecpyalloc(fields[RF_ABBRVAR]);
rules = (struct rule *) (void *) erealloc((char *) rules,
- (int) ((nrules + 1) * sizeof *rules));
+ (int) ((nrules + 1) * sizeof *rules));
rules[nrules++] = r;
}
-static int inzone(register char **fields, const int nfields)
+static int
+inzone(register char **fields, const int nfields)
{
- register int i;
- static char * buf;
+ register int i;
+ static char *buf;
- if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS) {
+ if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS)
+ {
error(_("wrong number of fields on Zone line"));
return FALSE;
}
- if (strcmp(fields[ZF_NAME], TZDEFAULT) == 0 && lcltime != NULL) {
+ if (strcmp(fields[ZF_NAME], TZDEFAULT) == 0 && lcltime != NULL)
+ {
buf = erealloc(buf, (int) (132 + strlen(TZDEFAULT)));
(void) sprintf(buf,
-_("\"Zone %s\" line and -l option are mutually exclusive"),
- TZDEFAULT);
+ _("\"Zone %s\" line and -l option are mutually exclusive"),
+ TZDEFAULT);
error(buf);
return FALSE;
}
- if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL) {
+ if (strcmp(fields[ZF_NAME], TZDEFRULES) == 0 && psxrules != NULL)
+ {
buf = erealloc(buf, (int) (132 + strlen(TZDEFRULES)));
(void) sprintf(buf,
-_("\"Zone %s\" line and -p option are mutually exclusive"),
- TZDEFRULES);
+ _("\"Zone %s\" line and -p option are mutually exclusive"),
+ TZDEFRULES);
error(buf);
return FALSE;
}
for (i = 0; i < nzones; ++i)
if (zones[i].z_name != NULL &&
- strcmp(zones[i].z_name, fields[ZF_NAME]) == 0) {
- buf = erealloc(buf, (int) (132 +
- strlen(fields[ZF_NAME]) +
- strlen(zones[i].z_filename)));
- (void) sprintf(buf,
-_("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)
+ {
+ buf = erealloc(buf, (int) (132 +
+ strlen(fields[ZF_NAME]) +
+ strlen(zones[i].z_filename)));
+ (void) sprintf(buf,
+ _("duplicate zone name %s (file \"%s\", line %d)"),
+ fields[ZF_NAME],
+ zones[i].z_filename,
+ zones[i].z_linenum);
+ error(buf);
+ return FALSE;
}
return inzsub(fields, nfields, FALSE);
}
-static int inzcont(register char **fields, const int nfields)
+static int
+inzcont(register char **fields, const int nfields)
{
- if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS) {
+ if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS)
+ {
error(_("wrong number of fields on Zone continuation line"));
return FALSE;
}
return inzsub(fields, nfields, TRUE);
}
-static int inzsub(register char **fields, const int nfields, const int iscont)
+static int
+inzsub(register char **fields, const int nfields, const int iscont)
{
- register char * cp;
- static struct zone z;
- register int i_gmtoff, i_rule, i_format;
- register int i_untilyear, i_untilmonth;
- register int i_untilday, i_untiltime;
- register int hasuntil;
-
- if (iscont) {
+ register char *cp;
+ static struct zone z;
+ register int i_gmtoff,
+ i_rule,
+ i_format;
+ register int i_untilyear,
+ i_untilmonth;
+ register int i_untilday,
+ i_untiltime;
+ register int hasuntil;
+
+ if (iscont)
+ {
i_gmtoff = ZFC_GMTOFF;
i_rule = ZFC_RULE;
i_format = ZFC_FORMAT;
i_untilday = ZFC_TILDAY;
i_untiltime = ZFC_TILTIME;
z.z_name = NULL;
- } else {
+ }
+ else
+ {
i_gmtoff = ZF_GMTOFF;
i_rule = ZF_RULE;
i_format = ZF_FORMAT;
z.z_filename = filename;
z.z_linenum = linenum;
z.z_gmtoff = gethms(fields[i_gmtoff], _("invalid UTC offset"), TRUE);
- if ((cp = strchr(fields[i_format], '%')) != 0) {
- if (*++cp != 's' || strchr(cp, '%') != 0) {
+ if ((cp = strchr(fields[i_format], '%')) != 0)
+ {
+ if (*++cp != 's' || strchr(cp, '%') != 0)
+ {
error(_("invalid abbreviation format"));
return FALSE;
}
z.z_rule = ecpyalloc(fields[i_rule]);
z.z_format = ecpyalloc(fields[i_format]);
hasuntil = nfields > i_untilyear;
- if (hasuntil) {
+ 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");
+ 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);
+ 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[nzones - 1].z_untiltime >= z.z_untiltime)
+ {
+ error(_("Zone continuation line end time is not after end time of previous line"));
+ return FALSE;
}
}
zones = (struct zone *) (void *) erealloc((char *) zones,
- (int) ((nzones + 1) * sizeof *zones));
+ (int) ((nzones + 1) * sizeof *zones));
zones[nzones++] = z;
+
/*
- ** If there was an UNTIL field on this line,
- ** there's more information about the zone on the next line.
- */
+ * * If there was an UNTIL field on this line, * there's more
+ * information about the zone on the next line.
+ */
return hasuntil;
}
-static void inleap(register char **fields, const int nfields)
+static void
+inleap(register char **fields, const int nfields)
{
- register const char * cp;
- register const struct lookup * lp;
- register int i, j;
- int year, month, day;
- long dayoff, tod;
- time_t t;
-
- if (nfields != LEAP_FIELDS) {
+ register const char *cp;
+ register const struct lookup *lp;
+ register int i,
+ j;
+ int year,
+ month,
+ day;
+ long dayoff,
+ tod;
+ time_t t;
+
+ if (nfields != LEAP_FIELDS)
+ {
error(_("wrong number of fields on Leap line"));
return;
}
dayoff = 0;
cp = fields[LP_YEAR];
- if (sscanf(cp, scheck(cp, "%d"), &year) != 1) {
- /*
- * Leapin' Lizards!
- */
- error(_("invalid leaping year"));
- return;
+ if (sscanf(cp, scheck(cp, "%d"), &year) != 1)
+ {
+ /*
+ * Leapin' Lizards!
+ */
+ error(_("invalid leaping year"));
+ return;
}
j = EPOCH_YEAR;
- while (j != year) {
- if (year > j) {
+ while (j != year)
+ {
+ if (year > j)
+ {
i = len_years[isleap(j)];
++j;
- } else {
+ }
+ else
+ {
--j;
i = -len_years[isleap(j)];
}
dayoff = oadd(dayoff, eitol(i));
}
- if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL) {
+ if ((lp = byword(fields[LP_MONTH], mon_names)) == NULL)
+ {
error(_("invalid month name"));
return;
}
month = lp->l_value;
j = TM_JANUARY;
- while (j != month) {
+ while (j != month)
+ {
i = len_months[isleap(year)][j];
dayoff = oadd(dayoff, eitol(i));
++j;
}
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(time_t)) {
+ if (dayoff < 0 && !TYPE_SIGNED(time_t))
+ {
error(_("time before zero"));
return;
}
- if (dayoff < min_time / SECSPERDAY) {
+ if (dayoff < min_time / SECSPERDAY)
+ {
error(_("time too small"));
return;
}
- if (dayoff > max_time / SECSPERDAY) {
+ if (dayoff > max_time / SECSPERDAY)
+ {
error(_("time too large"));
return;
}
- t = (time_t) dayoff * SECSPERDAY;
+ t = (time_t) dayoff *SECSPERDAY;
+
tod = gethms(fields[LP_TIME], _("invalid time of day"), FALSE);
cp = fields[LP_CORR];
{
- register int positive;
- int count;
+ register int positive;
+ int count;
- if (strcmp(cp, "") == 0) { /* infile() turns "-" into "" */
+ if (strcmp(cp, "") == 0)
+ { /* infile() turns "-" into "" */
positive = FALSE;
count = 1;
- } else if (strcmp(cp, "--") == 0) {
+ }
+ else if (strcmp(cp, "--") == 0)
+ {
positive = FALSE;
count = 2;
- } else if (strcmp(cp, "+") == 0) {
+ }
+ else if (strcmp(cp, "+") == 0)
+ {
positive = TRUE;
count = 1;
- } else if (strcmp(cp, "++") == 0) {
+ }
+ else if (strcmp(cp, "++") == 0)
+ {
positive = TRUE;
count = 2;
- } else {
+ }
+ else
+ {
error(_("illegal CORRECTION field on Leap line"));
return;
}
- if ((lp = byword(fields[LP_ROLL], leap_types)) == NULL) {
+ if ((lp = byword(fields[LP_ROLL], leap_types)) == NULL)
+ {
error(_("illegal Rolling/Stationary field on Leap line"));
return;
}
}
}
-static void inlink(register char **fields, const int nfields)
+static void
+inlink(register char **fields, const int nfields)
{
- struct link l;
+ struct link l;
- if (nfields != LINK_FIELDS) {
+ if (nfields != LINK_FIELDS)
+ {
error(_("wrong number of fields on Link line"));
return;
}
- if (*fields[LF_FROM] == '\0') {
+ if (*fields[LF_FROM] == '\0')
+ {
error(_("blank FROM field on Link line"));
return;
}
- if (*fields[LF_TO] == '\0') {
+ if (*fields[LF_TO] == '\0')
+ {
error(_("blank TO field on Link line"));
return;
}
l.l_from = ecpyalloc(fields[LF_FROM]);
l.l_to = ecpyalloc(fields[LF_TO]);
links = (struct link *) (void *) erealloc((char *) links,
- (int) ((nlinks + 1) * sizeof *links));
+ (int) ((nlinks + 1) * sizeof *links));
links[nlinks++] = l;
}
-static void rulesub(register struct rule *rp, const char *loyearp, const char *hiyearp, const char *typep, const char *monthp, const char *dayp, const char *timep)
+static void
+rulesub(register struct rule * rp, const char *loyearp, const char *hiyearp, const char *typep, const char *monthp, const char *dayp, const char *timep)
{
- register const struct lookup * lp;
- register const char * cp;
- register char * dp;
- register char * ep;
+ register const struct lookup *lp;
+ register const char *cp;
+ register char *dp;
+ register char *ep;
- if ((lp = byword(monthp, mon_names)) == NULL) {
+ if ((lp = byword(monthp, mon_names)) == NULL)
+ {
error(_("invalid month name"));
return;
}
rp->r_todisstd = FALSE;
rp->r_todisgmt = FALSE;
dp = ecpyalloc(timep);
- if (*dp != '\0') {
+ if (*dp != '\0')
+ {
ep = dp + strlen(dp) - 1;
- switch (lowerit(*ep)) {
- case 's': /* Standard */
+ switch (lowerit(*ep))
+ {
+ case 's': /* Standard */
rp->r_todisstd = TRUE;
rp->r_todisgmt = FALSE;
*ep = '\0';
break;
- case 'w': /* Wall */
+ case 'w': /* Wall */
rp->r_todisstd = FALSE;
rp->r_todisgmt = FALSE;
*ep = '\0';
break;
- case 'g': /* Greenwich */
- case 'u': /* Universal */
- case 'z': /* Zulu */
+ case 'g': /* Greenwich */
+ case 'u': /* Universal */
+ case 'z': /* Zulu */
rp->r_todisstd = TRUE;
rp->r_todisgmt = TRUE;
*ep = '\0';
}
rp->r_tod = gethms(dp, _("invalid time of day"), FALSE);
ifree(dp);
+
/*
- ** Year work.
- */
+ * * Year work.
+ */
cp = loyearp;
lp = byword(cp, begin_years);
- if (lp != NULL) switch ((int) lp->l_value) {
- case YR_MINIMUM:
- rp->r_loyear = INT_MIN;
- break;
- case YR_MAXIMUM:
- rp->r_loyear = INT_MAX;
- break;
- default: /* "cannot happen" */
- (void) fprintf(stderr,
- _("%s: panic: Invalid l_value %d\n"),
- progname, lp->l_value);
- (void) exit(EXIT_FAILURE);
- } else if (sscanf(cp, scheck(cp, "%d"), &rp->r_loyear) != 1) {
+ if (lp != NULL)
+ switch ((int) lp->l_value)
+ {
+ case YR_MINIMUM:
+ rp->r_loyear = INT_MIN;
+ break;
+ case YR_MAXIMUM:
+ rp->r_loyear = INT_MAX;
+ break;
+ default: /* "cannot happen" */
+ (void) fprintf(stderr,
+ _("%s: panic: Invalid l_value %d\n"),
+ progname, lp->l_value);
+ (void) exit(EXIT_FAILURE);
+ }
+ else if (sscanf(cp, scheck(cp, "%d"), &rp->r_loyear) != 1)
+ {
error(_("invalid starting year"));
return;
- } else if (noise) {
+ }
+ else if (noise)
+ {
if (rp->r_loyear < min_year_representable)
warning(_("starting year too low to be represented"));
else if (rp->r_loyear > max_year_representable)
warning(_("starting year too high to be represented"));
}
cp = hiyearp;
- if ((lp = byword(cp, end_years)) != NULL) switch ((int) lp->l_value) {
- case YR_MINIMUM:
- rp->r_hiyear = INT_MIN;
- break;
- case YR_MAXIMUM:
- rp->r_hiyear = INT_MAX;
- break;
- case YR_ONLY:
- rp->r_hiyear = rp->r_loyear;
- break;
- default: /* "cannot happen" */
- (void) fprintf(stderr,
- _("%s: panic: Invalid l_value %d\n"),
- progname, lp->l_value);
- (void) exit(EXIT_FAILURE);
- } else if (sscanf(cp, scheck(cp, "%d"), &rp->r_hiyear) != 1) {
+ if ((lp = byword(cp, end_years)) != NULL)
+ switch ((int) lp->l_value)
+ {
+ case YR_MINIMUM:
+ rp->r_hiyear = INT_MIN;
+ break;
+ case YR_MAXIMUM:
+ rp->r_hiyear = INT_MAX;
+ break;
+ case YR_ONLY:
+ rp->r_hiyear = rp->r_loyear;
+ break;
+ default: /* "cannot happen" */
+ (void) fprintf(stderr,
+ _("%s: panic: Invalid l_value %d\n"),
+ progname, lp->l_value);
+ (void) exit(EXIT_FAILURE);
+ }
+ else if (sscanf(cp, scheck(cp, "%d"), &rp->r_hiyear) != 1)
+ {
error(_("invalid ending year"));
return;
- } else if (noise) {
+ }
+ else if (noise)
+ {
if (rp->r_loyear < min_year_representable)
warning(_("ending year too low to be represented"));
else if (rp->r_loyear > max_year_representable)
warning(_("ending year too high to be represented"));
}
- if (rp->r_loyear > rp->r_hiyear) {
+ 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) {
+ else
+ {
+ if (rp->r_loyear == rp->r_hiyear)
+ {
error(_("typed single year"));
return;
}
}
if (rp->r_loyear < min_year && rp->r_loyear > 0)
min_year = rp->r_loyear;
+
/*
- ** Day work.
- ** Accept things such as:
- ** 1
- ** last-Sunday
- ** Sun<=20
- ** Sun>=7
- */
+ * * Day work. * Accept things such as: * 1 * last-Sunday * Sun<=20 *
+ * Sun>=7
+ */
dp = ecpyalloc(dayp);
- if ((lp = byword(dp, lasts)) != NULL) {
+ 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 {
+ }
+ else
+ {
if ((ep = strchr(dp, '<')) != 0)
rp->r_dycode = DC_DOWLEQ;
else if ((ep = strchr(dp, '>')) != 0)
rp->r_dycode = DC_DOWGEQ;
- else {
+ else
+ {
ep = dp;
rp->r_dycode = DC_DOM;
}
- if (rp->r_dycode != DC_DOM) {
+ if (rp->r_dycode != DC_DOM)
+ {
*ep++ = 0;
- if (*ep++ != '=') {
+ if (*ep++ != '=')
+ {
error(_("invalid day of month"));
ifree(dp);
return;
}
- if ((lp = byword(dp, wday_names)) == NULL) {
+ if ((lp = byword(dp, wday_names)) == NULL)
+ {
error(_("invalid weekday name"));
ifree(dp);
return;
}
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"));
- ifree(dp);
- return;
+ (rp->r_dayofmonth > len_months[1][rp->r_month]))
+ {
+ error(_("invalid day of month"));
+ ifree(dp);
+ return;
}
}
ifree(dp);
}
-static void convert(const long val, char *buf)
+static void
+convert(const long val, char *buf)
{
- register int i;
- register long shift;
+ register int i;
+ register long shift;
for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
buf[i] = val >> shift;
}
-static void puttzcode(const long val, FILE *fp)
+static void
+puttzcode(const long val, FILE *fp)
{
- char buf[4];
+ char buf[4];
convert(val, buf);
(void) fwrite((void *) buf, (size_t) sizeof buf, (size_t) 1, fp);
}
-static int atcomp(const void *avp,const void *bvp)
+static int
+atcomp(const void *avp, const void *bvp)
{
if (((struct attype *) avp)->at < ((struct attype *) bvp)->at)
return -1;
else if (((struct attype *) avp)->at > ((struct attype *) bvp)->at)
return 1;
- else return 0;
+ else
+ return 0;
}
-static void writezone(const char *name)
+static void
+writezone(const char *name)
{
- register FILE * fp;
- register int i, j;
- static char * fullname;
- static struct tzhead tzh;
- time_t ats[TZ_MAX_TIMES];
- unsigned char types[TZ_MAX_TIMES];
+ register FILE *fp;
+ register int i,
+ j;
+ static char *fullname;
+ static struct tzhead tzh;
+ time_t ats[TZ_MAX_TIMES];
+ unsigned char types[TZ_MAX_TIMES];
/*
- ** Sort.
- */
+ * * Sort.
+ */
if (timecnt > 1)
(void) qsort((void *) attypes, (size_t) timecnt,
- (size_t) sizeof *attypes, atcomp);
+ (size_t) sizeof *attypes, atcomp);
+
/*
- ** Optimize.
- */
+ * * Optimize.
+ */
{
- int fromi;
- int toi;
+ int fromi;
+ int toi;
toi = 0;
fromi = 0;
++fromi;
if (isdsts[0] == 0)
while (fromi < timecnt && attypes[fromi].type == 0)
- ++fromi; /* handled by default rule */
- for ( ; fromi < timecnt; ++fromi) {
+ ++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[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;
}
if (toi == 0 ||
attypes[toi - 1].type != attypes[fromi].type)
- attypes[toi++] = attypes[fromi];
+ attypes[toi++] = attypes[fromi];
}
timecnt = toi;
}
+
/*
- ** Transfer.
- */
- for (i = 0; i < timecnt; ++i) {
+ * * Transfer.
+ */
+ for (i = 0; i < timecnt; ++i)
+ {
ats[i] = attypes[i].at;
types[i] = attypes[i].type;
}
fullname = erealloc(fullname,
- (int) (strlen(directory) + 1 + strlen(name) + 1));
+ (int) (strlen(directory) + 1 + strlen(name) + 1));
(void) sprintf(fullname, "%s/%s", directory, name);
+
/*
- ** Remove old file, if any, to snap links.
- */
- if (!itsdir(fullname) && remove(fullname) != 0 && errno != ENOENT) {
+ * * Remove old file, if any, to snap links.
+ */
+ if (!itsdir(fullname) && remove(fullname) != 0 && errno != ENOENT)
+ {
const char *e = strerror(errno);
(void) fprintf(stderr, _("%s: Can't remove %s: %s\n"),
- progname, fullname, e);
+ progname, fullname, e);
(void) exit(EXIT_FAILURE);
}
- if ((fp = fopen(fullname, "wb")) == NULL) {
+ if ((fp = fopen(fullname, "wb")) == NULL)
+ {
if (mkdirs(fullname) != 0)
(void) exit(EXIT_FAILURE);
- if ((fp = fopen(fullname, "wb")) == NULL) {
+ if ((fp = fopen(fullname, "wb")) == NULL)
+ {
const char *e = strerror(errno);
(void) fprintf(stderr, _("%s: Can't create %s: %s\n"),
- progname, fullname, e);
+ progname, fullname, e);
(void) exit(EXIT_FAILURE);
}
}
DO(tzh_typecnt);
DO(tzh_charcnt);
#undef DO
- for (i = 0; i < timecnt; ++i) {
+ for (i = 0; i < timecnt; ++i)
+ {
j = leapcnt;
while (--j >= 0)
- if (ats[i] >= trans[j]) {
+ if (ats[i] >= trans[j])
+ {
ats[i] = tadd(ats[i], corr[j]);
break;
}
}
if (timecnt > 0)
(void) fwrite((void *) types, (size_t) sizeof types[0],
- (size_t) timecnt, fp);
- for (i = 0; i < typecnt; ++i) {
+ (size_t) timecnt, fp);
+ for (i = 0; i < typecnt; ++i)
+ {
puttzcode((long) gmtoffs[i], fp);
(void) putc(isdsts[i], fp);
(void) putc(abbrinds[i], fp);
}
if (charcnt != 0)
(void) fwrite((void *) chars, (size_t) sizeof chars[0],
- (size_t) charcnt, fp);
- for (i = 0; i < leapcnt; ++i) {
- if (roll[i]) {
- if (timecnt == 0 || trans[i] < ats[0]) {
+ (size_t) charcnt, fp);
+ for (i = 0; i < leapcnt; ++i)
+ {
+ if (roll[i])
+ {
+ if (timecnt == 0 || trans[i] < ats[0])
+ {
j = 0;
while (isdsts[j])
- if (++j >= typecnt) {
+ if (++j >= typecnt)
+ {
j = 0;
break;
}
- } else {
+ }
+ else
+ {
j = 1;
while (j < timecnt && trans[i] >= ats[j])
++j;
j = types[j - 1];
}
puttzcode((long) tadd(trans[i], -gmtoffs[j]), fp);
- } else puttzcode((long) trans[i], fp);
+ }
+ else
+ puttzcode((long) trans[i], fp);
puttzcode((long) corr[i], fp);
}
for (i = 0; i < typecnt; ++i)
(void) putc(ttisstds[i], fp);
for (i = 0; i < typecnt; ++i)
(void) putc(ttisgmts[i], fp);
- if (ferror(fp) || fclose(fp)) {
+ if (ferror(fp) || fclose(fp))
+ {
(void) fprintf(stderr, _("%s: Error writing %s\n"),
- progname, fullname);
+ progname, fullname);
(void) exit(EXIT_FAILURE);
}
}
-static void doabbr(char *abbr, const char *format, const char *letters, const int isdst)
+static void
+doabbr(char *abbr, const char *format, const char *letters, const int isdst)
{
- if (strchr(format, '/') == NULL) {
+ if (strchr(format, '/') == NULL)
+ {
if (letters == NULL)
(void) strcpy(abbr, format);
- else (void) sprintf(abbr, format, letters);
- } else if (isdst)
+ else
+ (void) sprintf(abbr, format, letters);
+ }
+ else if (isdst)
(void) strcpy(abbr, strchr(format, '/') + 1);
- else {
+ else
+ {
(void) strcpy(abbr, format);
*strchr(abbr, '/') = '\0';
}
}
-static void outzone(const struct zone *zpfirst, const int zonecount)
+static void
+outzone(const struct zone * zpfirst, const int zonecount)
{
- register const struct zone * zp;
- register struct rule * rp;
- register int i, j;
- register int usestart, useuntil;
- register time_t starttime = 0;
- register time_t untiltime = 0;
- register long gmtoff;
- register long stdoff;
- register int year;
- register long startoff;
- register int startttisstd;
- register int startttisgmt;
- register int type;
- char startbuf[BUFSIZ];
+ register const struct zone *zp;
+ register struct rule *rp;
+ register int i,
+ j;
+ register int usestart,
+ useuntil;
+ register time_t starttime = 0;
+ register time_t untiltime = 0;
+ register long gmtoff;
+ register long stdoff;
+ register int year;
+ register long startoff;
+ register int startttisstd;
+ register int startttisgmt;
+ register int type;
+ char startbuf[BUFSIZ];
/*
- ** Now. . .finally. . .generate some useful data!
- */
+ * * Now. . .finally. . .generate some useful data!
+ */
timecnt = 0;
typecnt = 0;
charcnt = 0;
+
/*
- ** Thanks to Earl Chew (earl@dnd.icp.nec.com.au)
- ** for noting the need to unconditionally initialize startttisstd.
- */
+ * * Thanks to Earl Chew (earl@dnd.icp.nec.com.au) * for noting the
+ * need to unconditionally initialize startttisstd.
+ */
startttisstd = FALSE;
startttisgmt = FALSE;
- for (i = 0; i < zonecount; ++i) {
+ for (i = 0; i < zonecount; ++i)
+ {
/*
- ** A guess that may well be corrected later.
- */
+ * * A guess that may well be corrected later.
+ */
stdoff = 0;
zp = &zpfirst[i];
usestart = i > 0 && (zp - 1)->z_untiltime > min_time;
eat(zp->z_filename, zp->z_linenum);
*startbuf = '\0';
startoff = zp->z_gmtoff;
- if (zp->z_nrules == 0) {
+ if (zp->z_nrules == 0)
+ {
stdoff = zp->z_stdoff;
doabbr(startbuf, zp->z_format,
- (char *) NULL, stdoff != 0);
+ (char *) NULL, stdoff != 0);
type = addtype(oadd(zp->z_gmtoff, stdoff),
- startbuf, stdoff != 0, startttisstd,
- startttisgmt);
- if (usestart) {
+ startbuf, stdoff != 0, startttisstd,
+ startttisgmt);
+ if (usestart)
+ {
addtt(starttime, type);
usestart = FALSE;
- } else if (stdoff != 0)
- addtt(min_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);
}
- for ( ; ; ) {
- register int k;
- register time_t jtime, ktime = 0;
- register long offset;
- char buf[BUFSIZ];
+ else if (stdoff != 0)
+ addtt(min_time, type);
+ }
+ else
+ for (year = min_year; year <= max_year; ++year)
+ {
+ if (useuntil && year > zp->z_untilrule.r_hiyear)
+ break;
- if (useuntil) {
- /*
- ** Turn untiltime into UTC
- ** 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) {
+ * * 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];
- 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;
- }
+ 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);
}
- 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->z_format,
- rp->r_abbrvar,
- rp->r_stdoff != 0);
- continue;
+ for (;;)
+ {
+ register int k;
+ register time_t jtime,
+ ktime = 0;
+ register long offset;
+ char buf[BUFSIZ];
+
+ if (useuntil)
+ {
+ /*
+ * * Turn untiltime into UTC * 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);
}
- if (*startbuf == '\0' &&
- startoff == oadd(zp->z_gmtoff,
- stdoff)) {
- doabbr(startbuf, zp->z_format,
- rp->r_abbrvar,
- rp->r_stdoff != 0);
+
+ /*
+ * * 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;
+ }
+ }
+ 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->z_format,
+ rp->r_abbrvar,
+ rp->r_stdoff != 0);
+ continue;
+ }
+ if (*startbuf == '\0' &&
+ startoff == oadd(zp->z_gmtoff,
+ stdoff))
+ {
+ doabbr(startbuf, zp->z_format,
+ rp->r_abbrvar,
+ rp->r_stdoff != 0);
+ }
}
+ eats(zp->z_filename, zp->z_linenum,
+ rp->r_filename, rp->r_linenum);
+ doabbr(buf, zp->z_format, rp->r_abbrvar,
+ rp->r_stdoff != 0);
+ offset = oadd(zp->z_gmtoff, rp->r_stdoff);
+ type = addtype(offset, buf, rp->r_stdoff != 0,
+ rp->r_todisstd, rp->r_todisgmt);
+ addtt(ktime, type);
}
- eats(zp->z_filename, zp->z_linenum,
- rp->r_filename, rp->r_linenum);
- doabbr(buf, zp->z_format, rp->r_abbrvar,
- rp->r_stdoff != 0);
- offset = oadd(zp->z_gmtoff, rp->r_stdoff);
- type = addtype(offset, buf, rp->r_stdoff != 0,
- rp->r_todisstd, rp->r_todisgmt);
- addtt(ktime, type);
}
- }
- if (usestart) {
+ if (usestart)
+ {
if (*startbuf == '\0' &&
zp->z_format != NULL &&
strchr(zp->z_format, '%') == NULL &&
strchr(zp->z_format, '/') == NULL)
- (void) strcpy(startbuf, zp->z_format);
+ (void) strcpy(startbuf, zp->z_format);
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.
- */
- if (useuntil) {
+ * * 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;
writezone(zpfirst->z_name);
}
-static void addtt(const time_t starttime, int type)
+static void
+addtt(const time_t starttime, int type)
{
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];
timecnt = 0;
type = 0;
}
- if (timecnt >= TZ_MAX_TIMES) {
+ if (timecnt >= TZ_MAX_TIMES)
+ {
error(_("too many transitions?!"));
(void) exit(EXIT_FAILURE);
}
++timecnt;
}
-static int addtype(const long gmtoff, const char *abbr, const int isdst, const int ttisstd, const int ttisgmt)
+static int
+addtype(const long gmtoff, const char *abbr, const int isdst, const int ttisstd, const int ttisgmt)
{
- register int i, j;
+ register int i,
+ j;
- if (isdst != TRUE && isdst != FALSE) {
+ if (isdst != TRUE && isdst != FALSE)
+ {
error(_("internal error - addtype called with bad isdst"));
(void) exit(EXIT_FAILURE);
}
- if (ttisstd != TRUE && ttisstd != FALSE) {
+ if (ttisstd != TRUE && ttisstd != FALSE)
+ {
error(_("internal error - addtype called with bad ttisstd"));
(void) exit(EXIT_FAILURE);
}
- if (ttisgmt != TRUE && ttisgmt != FALSE) {
+ if (ttisgmt != TRUE && ttisgmt != FALSE)
+ {
error(_("internal error - addtype called with bad ttisgmt"));
(void) exit(EXIT_FAILURE);
}
+
/*
- ** See if there's already an entry for this zone type.
- ** If so, just return its index.
- */
- for (i = 0; i < typecnt; ++i) {
+ * * 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;
+ return i;
}
+
/*
- ** There isn't one; add a new one, unless there are already too
- ** many.
- */
- if (typecnt >= TZ_MAX_TYPES) {
+ * * 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"));
(void) exit(EXIT_FAILURE);
}
return i;
}
-static void leapadd(const time_t t, const int positive, const int rolling, int count)
+static void
+leapadd(const time_t t, const int positive, const int rolling, int count)
{
- register int i, j;
+ register int i,
+ j;
- if (leapcnt + (positive ? count : 1) > TZ_MAX_LEAPS) {
+ if (leapcnt + (positive ? count : 1) > TZ_MAX_LEAPS)
+ {
error(_("too many leap seconds"));
(void) exit(EXIT_FAILURE);
}
for (i = 0; i < leapcnt; ++i)
- if (t <= trans[i]) {
- if (t == trans[i]) {
+ if (t <= trans[i])
+ {
+ if (t == trans[i])
+ {
error(_("repeated leap second moment"));
(void) exit(EXIT_FAILURE);
}
break;
}
- do {
- for (j = leapcnt; j > i; --j) {
+ do
+ {
+ for (j = leapcnt; j > i; --j)
+ {
trans[j] = trans[j - 1];
corr[j] = corr[j - 1];
roll[j] = roll[j - 1];
} while (positive && --count != 0);
}
-static void adjleap(void)
+static void
+adjleap(void)
{
- register int i;
- register long last = 0;
+ register int i;
+ register long last = 0;
/*
- ** propagate leap seconds forward
- */
- for (i = 0; i < leapcnt; ++i) {
+ * * propagate leap seconds forward
+ */
+ for (i = 0; i < leapcnt; ++i)
+ {
trans[i] = tadd(trans[i], last);
last = corr[i] += last;
}
}
-static int yearistype(const int year, const char *type)
+static int
+yearistype(const int year, const char *type)
{
- static char * buf;
- int result;
+ static char *buf;
+ int result;
if (type == NULL || *type == '\0')
return TRUE;
buf = erealloc(buf, (int) (132 + strlen(yitcommand) + strlen(type)));
(void) sprintf(buf, "%s %d %s", yitcommand, year, type);
result = system(buf);
- if (WIFEXITED(result)) switch (WEXITSTATUS(result)) {
- case 0:
- return TRUE;
- case 1:
- return FALSE;
- }
+ if (WIFEXITED(result))
+ switch (WEXITSTATUS(result))
+ {
+ case 0:
+ return TRUE;
+ case 1:
+ return FALSE;
+ }
error(_("Wild result from command execution"));
(void) fprintf(stderr, _("%s: command was '%s', result was %d\n"),
- progname, buf, result);
- for ( ; ; )
+ progname, buf, result);
+ for (;;)
(void) exit(EXIT_FAILURE);
}
-static int lowerit(int a)
+static int
+lowerit(int a)
{
a = (unsigned char) a;
return (isascii(a) && isupper(a)) ? tolower(a) : a;
}
-static int ciequal(register const char *ap, register const char *bp)
+static int
+ciequal(register const char *ap, register const char *bp)
{
while (lowerit(*ap) == lowerit(*bp++))
if (*ap++ == '\0')
return FALSE;
}
-static int itsabbr(register const char *abbr, register const char *word)
+static int
+itsabbr(register const char *abbr, register const char *word)
{
if (lowerit(*abbr) != lowerit(*word))
return FALSE;
++word;
while (*++abbr != '\0')
- do {
+ do
+ {
if (*word == '\0')
return FALSE;
} while (lowerit(*word++) != lowerit(*abbr));
return TRUE;
}
-static const struct lookup *byword(register const char *word, register const struct lookup *table)
+static const struct lookup *
+byword(register const char *word, register const struct lookup * table)
{
- register const struct lookup * foundlp;
- register const struct lookup * lp;
+ register const struct lookup *foundlp;
+ register const struct lookup *lp;
if (word == NULL || table == NULL)
return NULL;
+
/*
- ** Look for exact match.
- */
+ * * Look for exact match.
+ */
for (lp = table; lp->l_word != NULL; ++lp)
if (ciequal(word, lp->l_word))
return lp;
+
/*
- ** Look for inexact match.
- */
+ * * Look for inexact match.
+ */
foundlp = NULL;
for (lp = table; lp->l_word != NULL; ++lp)
- if (itsabbr(word, lp->l_word)) {
+ if (itsabbr(word, lp->l_word))
+ {
if (foundlp == NULL)
foundlp = lp;
- else return NULL; /* multiple inexact matches */
+ else
+ return NULL; /* multiple inexact matches */
}
return foundlp;
}
-static char **getfields(register char *cp)
+static char **
+getfields(register char *cp)
{
- register char * dp;
- register char ** array;
- register int nsubs;
+ register char *dp;
+ register char **array;
+ register int nsubs;
if (cp == NULL)
return NULL;
array = (char **) (void *)
emalloc((int) ((strlen(cp) + 1) * sizeof *array));
nsubs = 0;
- for ( ; ; ) {
+ for (;;)
+ {
while (isascii(*cp) && isspace((unsigned char) *cp))
++cp;
if (*cp == '\0' || *cp == '#')
break;
array[nsubs++] = dp = cp;
- do {
+ do
+ {
if ((*dp = *cp++) != '"')
++dp;
- else while ((*dp = *cp++) != '"')
- if (*dp != '\0')
- ++dp;
- else error(_("Odd number of quotation marks"));
+ else
+ while ((*dp = *cp++) != '"')
+ if (*dp != '\0')
+ ++dp;
+ else
+ error(_("Odd number of quotation marks"));
} while (*cp != '\0' && *cp != '#' &&
- (!isascii(*cp) || !isspace((unsigned char) *cp)));
+ (!isascii(*cp) || !isspace((unsigned char) *cp)));
if (isascii(*cp) && isspace((unsigned char) *cp))
++cp;
*dp = '\0';
return array;
}
-static long oadd(const long t1, const long t2)
+static long
+oadd(const long t1, const long t2)
{
- register long t;
+ register long t;
t = t1 + t2;
- if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
+ if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1))
+ {
error(_("time overflow"));
(void) exit(EXIT_FAILURE);
}
return t;
}
-static time_t tadd(const time_t t1, const long t2)
+static time_t
+tadd(const time_t t1, const long t2)
{
- register time_t t;
+ register time_t t;
if (t1 == max_time && t2 > 0)
return max_time;
if (t1 == min_time && t2 < 0)
return min_time;
t = t1 + t2;
- if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1)) {
+ if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1))
+ {
error(_("time overflow"));
(void) exit(EXIT_FAILURE);
}
** 1970, 00:00 LOCAL time - in that year that the rule refers to.
*/
-static time_t rpytime(register const struct rule *rp, register const int wantedy)
+static time_t
+rpytime(register const struct rule * rp, register const int wantedy)
{
- register int y, m, i;
- register long dayoff; /* with a nod to Margaret O. */
- register time_t t;
+ register int y,
+ m,
+ i;
+ register long dayoff; /* with a nod to Margaret O. */
+ register time_t t;
if (wantedy == INT_MIN)
return min_time;
dayoff = 0;
m = TM_JANUARY;
y = EPOCH_YEAR;
- while (wantedy != y) {
- if (wantedy > y) {
+ while (wantedy != y)
+ {
+ if (wantedy > y)
+ {
i = len_years[isleap(y)];
++y;
- } else {
+ }
+ else
+ {
--y;
i = -len_years[isleap(y)];
}
dayoff = oadd(dayoff, eitol(i));
}
- while (m != rp->r_month) {
+ while (m != rp->r_month)
+ {
i = len_months[isleap(y)][m];
dayoff = oadd(dayoff, eitol(i));
++m;
}
i = rp->r_dayofmonth;
- if (m == TM_FEBRUARY && i == 29 && !isleap(y)) {
+ if (m == TM_FEBRUARY && i == 29 && !isleap(y))
+ {
if (rp->r_dycode == DC_DOWLEQ)
--i;
- else {
+ else
+ {
error(_("use of 2/29 in non leap-year"));
(void) exit(EXIT_FAILURE);
}
}
--i;
dayoff = oadd(dayoff, eitol(i));
- if (rp->r_dycode == DC_DOWGEQ || rp->r_dycode == DC_DOWLEQ) {
- register long wday;
+ if (rp->r_dycode == DC_DOWGEQ || rp->r_dycode == DC_DOWLEQ)
+ {
+ register long wday;
#define LDAYSPERWEEK ((long) DAYSPERWEEK)
wday = eitol(EPOCH_WDAY);
+
/*
- ** Don't trust mod of negative numbers.
- */
+ * * Don't trust mod of negative numbers.
+ */
if (dayoff >= 0)
wday = (wday + dayoff) % LDAYSPERWEEK;
- else {
+ else
+ {
wday -= ((-dayoff) % LDAYSPERWEEK);
if (wday < 0)
wday += LDAYSPERWEEK;
}
while (wday != eitol(rp->r_wday))
- if (rp->r_dycode == DC_DOWGEQ) {
+ if (rp->r_dycode == DC_DOWGEQ)
+ {
dayoff = oadd(dayoff, (long) 1);
if (++wday >= LDAYSPERWEEK)
wday = 0;
++i;
- } else {
+ }
+ else
+ {
dayoff = oadd(dayoff, (long) -1);
if (--wday < 0)
wday = LDAYSPERWEEK - 1;
--i;
}
- if (i < 0 || i >= len_months[isleap(y)][m]) {
+ if (i < 0 || i >= len_months[isleap(y)][m])
+ {
error(_("no day in month matches rule"));
(void) exit(EXIT_FAILURE);
}
return min_time;
if (dayoff > max_time / SECSPERDAY)
return max_time;
- t = (time_t) dayoff * SECSPERDAY;
+ t = (time_t) dayoff *SECSPERDAY;
+
return tadd(t, rp->r_tod);
}
-static void newabbr(const char *string)
+static void
+newabbr(const char *string)
{
- register int i;
+ register int i;
i = strlen(string) + 1;
- if (charcnt + i > TZ_MAX_CHARS) {
+ if (charcnt + i > TZ_MAX_CHARS)
+ {
error(_("too many, or too long, time zone abbreviations"));
(void) exit(EXIT_FAILURE);
}
charcnt += eitol(i);
}
-static int mkdirs(char *argname)
+static int
+mkdirs(char *argname)
{
- register char * name;
- register char * cp;
+ register char *name;
+ register char *cp;
if (argname == NULL || *argname == '\0')
return 0;
cp = name = ecpyalloc(argname);
- while ((cp = strchr(cp + 1, '/')) != 0) {
+ while ((cp = strchr(cp + 1, '/')) != 0)
+ {
*cp = '\0';
#ifdef WIN32
+
/*
- ** DOS drive specifier?
- */
+ * * DOS drive specifier?
+ */
if (isalpha((unsigned char) name[0]) &&
- name[1] == ':' && name[2] == '\0') {
- *cp = '/';
- continue;
+ name[1] == ':' && name[2] == '\0')
+ {
+ *cp = '/';
+ continue;
}
-#endif /* WIN32 */
- if (!itsdir(name)) {
+#endif /* WIN32 */
+ if (!itsdir(name))
+ {
/*
- ** It doesn't seem to exist, so we try to create it.
- ** Creation may fail because of the directory being
- ** created by some other multiprocessor, so we get
- ** to do extra checking.
- */
- if (mkdir(name, MKDIR_UMASK) != 0) {
+ * * It doesn't seem to exist, so we try to create it. *
+ * Creation may fail because of the directory being * created
+ * by some other multiprocessor, so we get * to do extra
+ * checking.
+ */
+ if (mkdir(name, MKDIR_UMASK) != 0)
+ {
const char *e = strerror(errno);
- if (errno != EEXIST || !itsdir(name)) {
+ if (errno != EEXIST || !itsdir(name))
+ {
(void) fprintf(stderr,
-_("%s: Can't create directory %s: %s\n"),
- progname, name, e);
+ _("%s: Can't create directory %s: %s\n"),
+ progname, name, e);
ifree(name);
return -1;
}
return 0;
}
-static long eitol(const int i)
+static long
+eitol(const int i)
{
- long l;
+ long l;
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))
+ {
(void) fprintf(stderr,
- _("%s: %d did not sign extend correctly\n"),
- progname, i);
+ _("%s: %d did not sign extend correctly\n"),
+ progname, i);
(void) exit(EXIT_FAILURE);
}
return l;
#ifdef WIN32
/*
- * To run on win32
+ * To run on win32
*/
-int link(const char *oldpath, const char *newpath) {
- if (!CopyFileEx(oldpath, newpath, NULL, NULL, FALSE, 0)) {
+int
+link(const char *oldpath, const char *newpath)
+{
+ if (!CopyFileEx(oldpath, newpath, NULL, NULL, FALSE, 0))
return -1;
- }
return 0;
}
#endif
projects / postgresql.git / commitdiff