*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/timezone/ialloc.c,v 1.5 2004/05/21 20:59:10 tgl Exp $
+ * $PostgreSQL: pgsql/src/timezone/ialloc.c,v 1.6 2005/06/20 08:00:51 neilc Exp $
*/
#include "postgres.h"
char *
icatalloc(char *old, const char *new)
{
- register char *result;
- register int oldsize,
- newsize;
+ char *result;
+ int oldsize,
+ newsize;
newsize = (new == NULL) ? 0 : strlen(new);
if (old == NULL)
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/timezone/localtime.c,v 1.10 2005/04/19 03:13:59 momjian Exp $
+ * $PostgreSQL: pgsql/src/timezone/localtime.c,v 1.11 2005/06/20 08:00:51 neilc Exp $
*/
/*
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 pg_time_t *timep, long offset, struct pg_tm * tmp);
-static void localsub(const pg_time_t *timep, long offset, struct pg_tm * tmp, const pg_tz *tz);
+static const char *getrule(const char *strp, struct rule *rulep);
+static void gmtload(struct state *sp);
+static void gmtsub(const pg_time_t *timep, long offset, struct pg_tm *tmp);
+static void localsub(const pg_time_t *timep, long offset, struct pg_tm *tmp, const pg_tz *tz);
static void timesub(const pg_time_t *timep, long offset,
- const struct state * sp, struct pg_tm * tmp);
+ const struct state *sp, struct pg_tm *tmp);
static pg_time_t transtime(pg_time_t janfirst, int year,
- const struct rule * rulep, long offset);
-int tzparse(const char *name, struct state * sp, int lastditch);
+ const struct rule *rulep, long offset);
+int tzparse(const char *name, struct state *sp, int lastditch);
/* GMT timezone */
static struct state gmtmem;
static long
detzcode(const char *codep)
{
- register long result;
- register int i;
+ long result;
+ int i;
result = (codep[0] & 0x80) ? ~0L : 0L;
for (i = 0; i < 4; ++i)
}
int
-tzload(register const char *name, register struct state * sp)
+tzload(const char *name, struct state *sp)
{
- register const char *p;
- register int i;
- register int fid;
+ const char *p;
+ int i;
+ int fid;
if (name == NULL && (name = TZDEFAULT) == NULL)
return -1;
{
- register int doaccess;
+ int doaccess;
char fullname[MAXPGPATH];
if (name[0] == ':')
}
for (i = 0; i < sp->typecnt; ++i)
{
- register struct ttinfo *ttisp;
+ struct ttinfo *ttisp;
ttisp = &sp->ttis[i];
ttisp->tt_gmtoff = detzcode(p);
sp->chars[i] = '\0'; /* ensure '\0' at end */
for (i = 0; i < sp->leapcnt; ++i)
{
- register struct lsinfo *lsisp;
+ struct lsinfo *lsisp;
lsisp = &sp->lsis[i];
lsisp->ls_trans = detzcode(p);
}
for (i = 0; i < sp->typecnt; ++i)
{
- register struct ttinfo *ttisp;
+ struct ttinfo *ttisp;
ttisp = &sp->ttis[i];
if (ttisstdcnt == 0)
}
for (i = 0; i < sp->typecnt; ++i)
{
- register struct ttinfo *ttisp;
+ struct ttinfo *ttisp;
ttisp = &sp->ttis[i];
if (ttisgmtcnt == 0)
* character.
*/
static const char *
-getzname(register const char *strp)
+getzname(const char *strp)
{
- register char c;
+ char c;
while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' &&
c != '+')
* 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)
+getnum(const char *strp, int *nump, int min, int max)
{
- register char c;
- register int num;
+ char c;
+ int num;
if (strp == NULL || !is_digit(c = *strp))
return NULL;
* of seconds.
*/
static const char *
-getsecs(register const char *strp, long *secsp)
+getsecs(const char *strp, long *secsp)
{
int num;
* Otherwise, return a pointer to the first character not part of the time.
*/
static const char *
-getoffset(register const char *strp, long *offsetp)
+getoffset(const char *strp, long *offsetp)
{
- register int neg = 0;
+ int neg = 0;
if (*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)
+getrule(const char *strp, struct rule *rulep)
{
if (*strp == 'J')
{
* calculate the Epoch-relative time that rule takes effect.
*/
static pg_time_t
-transtime(const pg_time_t janfirst, const int year,
- register const struct rule * rulep, const long offset)
+transtime(const pg_time_t janfirst, int year,
+ const struct rule *rulep, long offset)
{
- register int leapyear;
- register pg_time_t value = 0;
- register int i;
- int d,
+ int leapyear;
+ pg_time_t value = 0;
+ int i,
+ d,
m1,
yy0,
yy1,
*/
int
-tzparse(const char *name, register struct state * sp, const int lastditch)
+tzparse(const char *name, struct state *sp, int lastditch)
{
const char *stdname;
const char *dstname = NULL;
size_t dstlen;
long stdoffset;
long dstoffset;
- register pg_time_t *atp;
- register unsigned char *typep;
- register char *cp;
- register int load_result;
+ pg_time_t *atp;
+ unsigned char *typep;
+ char *cp;
+ int load_result;
stdname = name;
if (lastditch)
{
struct rule start;
struct rule end;
- register int year;
- register pg_time_t janfirst;
+ int year;
+ pg_time_t janfirst;
pg_time_t starttime;
pg_time_t endtime;
}
else
{
- register long theirstdoffset;
- register long theirdstoffset;
- register long theiroffset;
- register int isdst;
- register int i;
- register int j;
+ long theirstdoffset;
+ long theirdstoffset;
+ long theiroffset;
+ int isdst;
+ int i;
+ int j;
if (*name != '\0')
return -1;
}
static void
-gmtload(struct state * sp)
+gmtload(struct state *sp)
{
if (tzload(gmt, sp) != 0)
(void) tzparse(gmt, sp, TRUE);
* The unused offset argument is for the benefit of mktime variants.
*/
static void
-localsub(const pg_time_t *timep, const long offset, struct pg_tm * tmp, const pg_tz *tz)
+localsub(const pg_time_t *timep, long offset, struct pg_tm *tmp, const pg_tz *tz)
{
- register const struct state *sp;
- register const struct ttinfo *ttisp;
- register int i;
+ const struct state *sp;
+ const struct ttinfo *ttisp;
+ int i;
const pg_time_t t = *timep;
sp = &tz->state;
* gmtsub is to gmtime as localsub is to localtime.
*/
static void
-gmtsub(const pg_time_t *timep, const long offset, struct pg_tm * tmp)
+gmtsub(const pg_time_t *timep, long offset, struct pg_tm *tmp)
{
if (!gmt_is_set)
{
static void
-timesub(const pg_time_t *timep, const long offset,
- register const struct state * sp, register struct pg_tm * tmp)
+timesub(const pg_time_t *timep, long offset,
+ const struct state *sp, struct pg_tm *tmp)
{
- register const struct lsinfo *lp;
+ const struct lsinfo *lp;
/* expand days to 64 bits to support full Julian-day range */
- register int64 days;
- register int idays;
- register long rem;
- register int y;
- register int yleap;
- register const int *ip;
- register long corr;
- register int hit;
- register int i;
+ int64 days;
+ int idays;
+ long rem;
+ int y;
+ int yleap;
+ const int *ip;
+ long corr;
+ int hit;
+ int i;
corr = 0;
hit = 0;
#define LEAPS_THRU_END_OF(y) (((y) + 4800) / 4 - ((y) + 4800) / 100 + ((y) + 4800) / 400)
while (days < 0 || days >= (int64) year_lengths[yleap = isleap(y)])
{
- register int newy;
+ int newy;
newy = y + days / DAYSPERNYEAR;
if (days < 0)
int *after_isdst,
const pg_tz *tz)
{
- register const struct state *sp;
- register const struct ttinfo *ttisp;
+ const struct state *sp;
+ const struct ttinfo *ttisp;
int i;
int j;
const pg_time_t t = *timep;
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/timezone/pgtz.c,v 1.34 2005/06/19 21:34:03 tgl Exp $
+ * $PostgreSQL: pgsql/src/timezone/pgtz.c,v 1.35 2005/06/20 08:00:51 neilc Exp $
*
*-------------------------------------------------------------------------
*/
* Get GMT offset from a system struct tm
*/
static int
-get_timezone_offset(struct tm * tm)
+get_timezone_offset(struct tm *tm)
{
#if defined(HAVE_STRUCT_TM_TM_ZONE)
return tm->tm_gmtoff;
* Does a system tm value match one we computed ourselves?
*/
static bool
-compare_tm(struct tm * s, struct pg_tm * p)
+compare_tm(struct tm *s, struct pg_tm *p)
{
if (s->tm_sec != p->tm_sec ||
s->tm_min != p->tm_min ||
* test time.
*/
static int
-score_timezone(const char *tzname, struct tztry * tt)
+score_timezone(const char *tzname, struct tztry *tt)
{
int i;
pg_time_t pgtt;
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/timezone/scheck.c,v 1.5 2004/05/21 20:59:10 tgl Exp $
+ * $PostgreSQL: pgsql/src/timezone/scheck.c,v 1.6 2005/06/20 08:00:51 neilc Exp $
*/
#include "postgres.h"
char *
scheck(const char *string, const char *format)
{
- register char *fbuf;
- register const char *fp;
- register char *tp;
- register int c;
- register char *result;
+ char *fbuf;
+ const char *fp;
+ char *tp;
+ int c;
+ char *result;
char dummy;
static char nada;
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/timezone/strftime.c,v 1.6 2005/04/19 03:13:59 momjian Exp $
+ * $PostgreSQL: pgsql/src/timezone/strftime.c,v 1.7 2005/06/20 08:00:51 neilc Exp $
*/
#include "postgres.h"
size_t
pg_strftime(char *s, size_t maxsize, const char *format,
- const struct pg_tm * t)
+ const struct pg_tm *t)
{
char *p;
int warn;
}
static char *
-_fmt(const char *format, const struct pg_tm * t, char *pt, const char *ptlim,
+_fmt(const char *format, const struct pg_tm *t, char *pt, const char *ptlim,
int *warnp)
{
for (; *format; ++format)
}
static char *
-_conv(const int n, const char *format, char *pt, const char *ptlim)
+_conv(int n, const char *format, char *pt, const char *ptlim)
{
char buf[INT_STRLEN_MAXIMUM(int) +1];
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/timezone/zic.c,v 1.14 2005/04/19 03:13:59 momjian Exp $
+ * $PostgreSQL: pgsql/src/timezone/zic.c,v 1.15 2005/06/20 08:00:51 neilc Exp $
*/
#include "postgres.h"
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 outzone(const struct zone *zp, int ntzones);
static void puttzcode(long code, FILE *fp);
static int rcomp(const void *leftp, const void *rightp);
-static pg_time_t rpytime(const struct rule * rp, int wantedy);
-static void rulesub(struct rule * rp,
+static pg_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
-eats(const char *name, const int num, const char *rname, const int rnum)
+eats(const char *name, int num, const char *rname, int rnum)
{
filename = name;
linenum = num;
}
static void
-eat(const char *name, const int num)
+eat(const char *name, int num)
{
eats(name, num, (char *) NULL, -1);
}
int
main(int argc, char *argv[])
{
- register int i;
- register int j;
- register int c;
+ int i;
+ int j;
+ int c;
#ifndef WIN32
(void) umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
static void
dolink(const char *fromfile, const char *tofile)
{
- register char *fromname;
- register char *toname;
+ char *fromname;
+ char *toname;
if (fromfile[0] == '/')
fromname = ecpyalloc(fromfile);
!itsdir(fromname))
{
const char *s = tofile;
- register char *symlinkcontents = NULL;
+ char *symlinkcontents = NULL;
while ((s = strchr(s + 1, '/')) != NULL)
symlinkcontents = ecatalloc(symlinkcontents, "../");
static int
itsdir(const char *name)
{
- register char *myname;
- register int accres;
+ char *myname;
+ int accres;
myname = ecpyalloc(name);
myname = ecatalloc(myname, "/.");
static void
associate(void)
{
- register struct zone *zp;
- register struct rule *rp;
- register int base,
- out;
- register int i,
- j;
+ struct zone *zp;
+ struct rule *rp;
+ int base,
+ out;
+ int i,
+ j;
if (nrules != 0)
{
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;
+ FILE *fp;
+ char **fields;
+ char *cp;
+ const struct lookup *lp;
+ int nfields;
+ int wantcont;
+ int num;
char buf[BUFSIZ];
if (strcmp(name, "-") == 0)
*----------
*/
static long
-gethms(const char *string, const char *errstring, const int signable)
+gethms(const char *string, const char *errstring, int signable)
{
int hh,
mm,
}
static void
-inrule(register char **fields, const int nfields)
+inrule(char **fields, int nfields)
{
static struct rule r;
}
static int
-inzone(register char **fields, const int nfields)
+inzone(char **fields, int nfields)
{
- register int i;
+ int i;
static char *buf;
if (nfields < ZONE_MINFIELDS || nfields > ZONE_MAXFIELDS)
}
static int
-inzcont(register char **fields, const int nfields)
+inzcont(char **fields, int nfields)
{
if (nfields < ZONEC_MINFIELDS || nfields > ZONEC_MAXFIELDS)
{
}
static int
-inzsub(register char **fields, const int nfields, const int iscont)
+inzsub(char **fields, int nfields, int iscont)
{
- register char *cp;
+ 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;
+ int i_gmtoff,
+ i_rule,
+ i_format;
+ int i_untilyear,
+ i_untilmonth;
+ int i_untilday,
+ i_untiltime;
+ int hasuntil;
if (iscont)
{
}
static void
-inleap(register char **fields, const int nfields)
+inleap(char **fields, int nfields)
{
- register const char *cp;
- register const struct lookup *lp;
- register int i,
+ const char *cp;
+ const struct lookup *lp;
+ int i,
j;
int year,
month,
tod = gethms(fields[LP_TIME], _("invalid time of day"), FALSE);
cp = fields[LP_CORR];
{
- register int positive;
+ int positive;
int count;
if (strcmp(cp, "") == 0)
}
static void
-inlink(register char **fields, const int nfields)
+inlink(char **fields, int nfields)
{
struct link l;
}
static void
-rulesub(register struct rule * rp, const char *loyearp, const char *hiyearp,
+rulesub(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;
+ const struct lookup *lp;
+ const char *cp;
+ char *dp;
+ char *ep;
if ((lp = byword(monthp, mon_names)) == NULL)
{
}
static void
-convert(const long val, char *buf)
+convert(long val, char *buf)
{
- register int i;
- register long shift;
+ int i;
+ long shift;
for (i = 0, shift = 24; i < 4; ++i, shift -= 8)
buf[i] = val >> shift;
}
static void
-puttzcode(const long val, FILE *fp)
+puttzcode(long val, FILE *fp)
{
char buf[4];
static void
writezone(const char *name)
{
- register FILE *fp;
- register int i,
- j;
+ FILE *fp;
+ int i,
+ j;
static char *fullname;
static struct tzhead tzh;
pg_time_t ats[TZ_MAX_TIMES];
}
static void
-doabbr(char *abbr, const char *format, const char *letters, const int isdst)
+doabbr(char *abbr, const char *format, const char *letters, int isdst)
{
if (strchr(format, '/') == NULL)
{
}
static void
-outzone(const struct zone * zpfirst, const int zonecount)
+outzone(const struct zone *zpfirst, int zonecount)
{
- register const struct zone *zp;
- register struct rule *rp;
- register int i,
- j;
- register int usestart,
- useuntil;
- register pg_time_t starttime = 0;
- register pg_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;
+ const struct zone *zp;
+ struct rule *rp;
+ int i,
+ j;
+ int usestart,
+ useuntil;
+ pg_time_t starttime = 0;
+ pg_time_t untiltime = 0;
+ long gmtoff;
+ long stdoff;
+ int year;
+ long startoff;
+ int startttisstd;
+ int startttisgmt;
+ int type;
char startbuf[BUFSIZ];
/*
}
for (;;)
{
- register int k;
- register pg_time_t jtime,
- ktime = 0;
- register long offset;
+ int k;
+ pg_time_t jtime, ktime = 0;
+ long offset;
char buf[BUFSIZ];
if (useuntil)
}
static int
-addtype(const long gmtoff, const char *abbr, const int isdst,
- const int ttisstd, const int ttisgmt)
+addtype(long gmtoff, const char *abbr, int isdst,
+ int ttisstd, int ttisgmt)
{
- register int i,
- j;
+ int i;
+ int j;
if (isdst != TRUE && isdst != FALSE)
{
}
static void
-leapadd(const pg_time_t t, const int positive, const int rolling, int count)
+leapadd(const pg_time_t t, int positive, int rolling, int count)
{
- register int i,
- j;
+ int i;
+ int j;
if (leapcnt + (positive ? count : 1) > TZ_MAX_LEAPS)
{
static void
adjleap(void)
{
- register int i;
- register long last = 0;
+ int i;
+ long last = 0;
/*
* propagate leap seconds forward
}
static int
-yearistype(const int year, const char *type)
+yearistype(int year, const char *type)
{
static char *buf;
int result;
}
static int
-ciequal(register const char *ap, register const char *bp)
+ciequal(const char *ap, const char *bp)
{
while (lowerit(*ap) == lowerit(*bp++))
if (*ap++ == '\0')
}
static int
-itsabbr(register const char *abbr, register const char *word)
+itsabbr(const char *abbr, const char *word)
{
if (lowerit(*abbr) != lowerit(*word))
return FALSE;
}
static const struct lookup *
-byword(register const char *word, register const struct lookup * table)
+byword(const char *word, const struct lookup *table)
{
- register const struct lookup *foundlp;
- register const struct lookup *lp;
+ const struct lookup *foundlp;
+ const struct lookup *lp;
if (word == NULL || table == NULL)
return NULL;
}
static char **
-getfields(register char *cp)
+getfields(char *cp)
{
- register char *dp;
- register char **array;
- register int nsubs;
+ char *dp;
+ char **array;
+ int nsubs;
if (cp == NULL)
return NULL;
}
static long
-oadd(const long t1, const long t2)
+oadd(long t1, long t2)
{
- register long t;
+ long t;
t = t1 + t2;
if ((t2 > 0 && t <= t1) || (t2 < 0 && t >= t1))
}
static pg_time_t
-tadd(const pg_time_t t1, const long t2)
+tadd(const pg_time_t t1, long t2)
{
- register pg_time_t t;
+ pg_time_t t;
if (t1 == max_time && t2 > 0)
return max_time;
*/
static pg_time_t
-rpytime(register const struct rule * rp, register const int wantedy)
+rpytime(const struct rule *rp, int wantedy)
{
- register int y,
- m,
- i;
- register long dayoff; /* with a nod to Margaret O. */
- register pg_time_t t;
+ int y,
+ m,
+ i;
+ long dayoff; /* with a nod to Margaret O. */
+ pg_time_t t;
if (wantedy == INT_MIN)
return min_time;
dayoff = oadd(dayoff, eitol(i));
if (rp->r_dycode == DC_DOWGEQ || rp->r_dycode == DC_DOWLEQ)
{
- register long wday;
+ long wday;
#define LDAYSPERWEEK ((long) DAYSPERWEEK)
wday = eitol(EPOCH_WDAY);
static void
newabbr(const char *string)
{
- register int i;
+ int i;
i = strlen(string) + 1;
if (charcnt + i > TZ_MAX_CHARS)
static int
mkdirs(char *argname)
{
- register char *name;
- register char *cp;
+ char *name;
+ char *cp;
if (argname == NULL || *argname == '\0')
return 0;
}
static long
-eitol(const int i)
+eitol(int i)
{
long l;
projects / postgresql.git / commitdiff