← Back to branch summary

~ubuntu-branches/ubuntu/trusty/postgresql-8.4/trusty

« back to all changes in this revision

Viewing changes to src/timezone/localtime.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2009-07-11 16:59:35 UTC
  • mfrom: (5.1.1 karmic)
  • Revision ID: james.westby@ubuntu.com-20090711165935-jfwin6gfrxf0gfsi
Tags: 8.4.0-2
http://bugs.debian.org/536139
* debian/libpq-dev.install: Ship catalog/genbki.h. (Closes: #536139)
* debian/rules: Drop --enable-cassert for final release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/timezone/localtime.c
3
3
 * 1996-06-05 by Arthur David Olson.
4
4
 *
5
5
 * IDENTIFICATION
6
 
 *        $PostgreSQL: pgsql/src/timezone/localtime.c,v 1.20 2008/02/16 21:16:04 tgl Exp $
 
6
 *        $PostgreSQL: pgsql/src/timezone/localtime.c,v 1.21 2009/06/11 14:49:15 momjian Exp $
7
7
 */
8
8
 
9
9
/*
77
77
 
78
78
static long detzcode(const char *codep);
79
79
static pg_time_t detzcode64(const char *codep);
80
 
static int differ_by_repeat(pg_time_t t1, pg_time_t t0);
 
80
static int      differ_by_repeat(pg_time_t t1, pg_time_t t0);
81
81
static const char *getzname(const char *strp);
82
82
static const char *getqzname(const char *strp, int delim);
83
83
static const char *getnum(const char *strp, int *nump, int min, int max);
85
85
static const char *getoffset(const char *strp, long *offsetp);
86
86
static const char *getrule(const char *strp, struct rule * rulep);
87
87
static void gmtload(struct state * sp);
88
 
static struct pg_tm *gmtsub(const pg_time_t *timep, long offset, 
89
 
                                                        struct pg_tm *tmp);
90
 
static struct pg_tm *localsub(const pg_time_t *timep, long offset, 
91
 
                                                           struct pg_tm *tmp, const pg_tz *tz);
92
 
static int increment_overflow(int *number, int delta);
 
88
static struct pg_tm *gmtsub(const pg_time_t *timep, long offset,
 
89
           struct pg_tm * tmp);
 
90
static struct pg_tm *localsub(const pg_time_t *timep, long offset,
 
91
                 struct pg_tm * tmp, const pg_tz *tz);
 
92
static int      increment_overflow(int *number, int delta);
93
93
static pg_time_t transtime(pg_time_t janfirst, int year,
94
 
                  const struct rule *rulep, long offset);
95
 
static int typesequiv(const struct state *sp, int a, int b);
 
94
                  const struct rule * rulep, long offset);
 
95
static int      typesequiv(const struct state * sp, int a, int b);
96
96
static struct pg_tm *timesub(const pg_time_t *timep, long offset,
97
 
                                                         const struct state *sp, struct pg_tm *tmp);
 
97
                const struct state * sp, struct pg_tm * tmp);
98
98
 
99
99
/* GMT timezone */
100
100
static struct state gmtmem;
130
130
static pg_time_t
131
131
detzcode64(const char *codep)
132
132
{
133
 
        pg_time_t result;
134
 
        int    i;
 
133
        pg_time_t       result;
 
134
        int                     i;
135
135
 
136
 
        result = (codep[0] & 0x80) ?  (~(int64) 0) : 0;
 
136
        result = (codep[0] & 0x80) ? (~(int64) 0) : 0;
137
137
        for (i = 0; i < 8; ++i)
138
138
                result = result * 256 + (codep[i] & 0xff);
139
139
        return result;
143
143
differ_by_repeat(pg_time_t t1, pg_time_t t0)
144
144
{
145
145
        if (TYPE_INTEGRAL(pg_time_t) &&
146
 
                TYPE_BIT(pg_time_t) - TYPE_SIGNED(pg_time_t) < SECSPERREPEAT_BITS)
 
146
                TYPE_BIT(pg_time_t) -TYPE_SIGNED(pg_time_t) <SECSPERREPEAT_BITS)
147
147
                return 0;
148
148
        return t1 - t0 == SECSPERREPEAT;
149
149
}
160
160
        {
161
161
                struct tzhead tzhead;
162
162
                char            buf[2 * sizeof(struct tzhead) +
163
 
                                                2 * sizeof *sp +
164
 
                                                4 * TZ_MAX_TIMES];
165
 
        } u;
 
163
                                                                        2 * sizeof *sp +
 
164
                                                                        4 * TZ_MAX_TIMES];
 
165
        }                       u;
166
166
 
167
167
        if (name == NULL && (name = TZDEFAULT) == NULL)
168
168
                return -1;
194
194
                        (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
195
195
                        return -1;
196
196
                if (nread - (p - u.buf) <
197
 
                        sp->timecnt * stored + /* ats */
 
197
                        sp->timecnt * stored +          /* ats */
198
198
                        sp->timecnt +           /* types */
199
 
                        sp->typecnt * 6 +               /* ttinfos */
 
199
                        sp->typecnt * 6 +       /* ttinfos */
200
200
                        sp->charcnt +           /* chars */
201
201
                        sp->leapcnt * (stored + 4) +            /* lsinfos */
202
202
                        ttisstdcnt +            /* ttisstds */
271
271
                                        return -1;
272
272
                        }
273
273
                }
 
274
 
274
275
                /*
275
 
                 * Out-of-sort ats should mean we're running on a
276
 
                 * signed time_t system but using a data file with
277
 
                 * unsigned values (or vice versa).
 
276
                 * Out-of-sort ats should mean we're running on a signed time_t system
 
277
                 * but using a data file with unsigned values (or vice versa).
278
278
                 */
279
279
                for (i = 0; i < sp->timecnt - 2; ++i)
280
280
                        if (sp->ats[i] > sp->ats[i + 1])
292
292
                                        /*
293
293
                                         * Ignore the beginning (harder).
294
294
                                         */
295
 
                                        int j;
296
 
                                        
 
295
                                        int                     j;
 
296
 
297
297
                                        for (j = 0; j + i < sp->timecnt; ++j)
298
298
                                        {
299
299
                                                sp->ats[j] = sp->ats[j + i];
303
303
                                }
304
304
                                break;
305
305
                        }
 
306
 
306
307
                /*
307
308
                 * If this is an old file, we're done.
308
309
                 */
311
312
                nread -= p - u.buf;
312
313
                for (i = 0; i < nread; ++i)
313
314
                        u.buf[i] = p[i];
 
315
 
314
316
                /*
315
317
                 * If this is a narrow integer time_t system, we're done.
316
318
                 */
321
323
                u.buf[0] == '\n' && u.buf[nread - 1] == '\n' &&
322
324
                sp->typecnt + 2 <= TZ_MAX_TYPES)
323
325
        {
324
 
                struct state    ts;
325
 
                int    result;
326
 
 
 
326
                struct state ts;
 
327
                int                     result;
 
328
 
327
329
                u.buf[nread - 1] = '\0';
328
330
                result = tzparse(&u.buf[1], &ts, FALSE);
329
331
                if (result == 0 && ts.typecnt == 2 &&
369
371
}
370
372
 
371
373
static int
372
 
typesequiv(const struct state *sp, int a, int b)
 
374
typesequiv(const struct state * sp, int a, int b)
373
375
{
374
 
        int    result;
 
376
        int                     result;
375
377
 
376
378
        if (sp == NULL ||
377
379
                a < 0 || a >= sp->typecnt ||
428
430
static const char *
429
431
getqzname(const char *strp, int delim)
430
432
{
431
 
        int    c;
 
433
        int                     c;
432
434
 
433
435
        while ((c = *strp) != '\0' && c != delim)
434
436
                ++strp;
814
816
                                 sp->timecnt + 2 <= TZ_MAX_TIMES;
815
817
                                 ++year)
816
818
                        {
817
 
                                pg_time_t newfirst;
 
819
                                pg_time_t       newfirst;
818
820
 
819
821
                                starttime = transtime(janfirst, year, &start,
820
822
                                                                          stdoffset);
986
988
 */
987
989
static struct pg_tm *
988
990
localsub(const pg_time_t *timep, long offset,
989
 
                 struct pg_tm *tmp, const pg_tz *tz)
 
991
                 struct pg_tm * tmp, const pg_tz *tz)
990
992
{
991
993
        const struct state *sp;
992
994
        const struct ttinfo *ttisp;
1002
1004
                pg_time_t       seconds;
1003
1005
                pg_time_t       tcycles;
1004
1006
                int64           icycles;
1005
 
 
 
1007
 
1006
1008
                if (t < sp->ats[0])
1007
1009
                        seconds = sp->ats[0] - t;
1008
 
                else    seconds = t - sp->ats[sp->timecnt - 1];
 
1010
                else
 
1011
                        seconds = t - sp->ats[sp->timecnt - 1];
1009
1012
                --seconds;
1010
1013
                tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
1011
1014
                ++tcycles;
1017
1020
                seconds *= AVGSECSPERYEAR;
1018
1021
                if (t < sp->ats[0])
1019
1022
                        newt += seconds;
1020
 
                else    newt -= seconds;
 
1023
                else
 
1024
                        newt -= seconds;
1021
1025
                if (newt < sp->ats[0] ||
1022
1026
                        newt > sp->ats[sp->timecnt - 1])
1023
 
                        return NULL;    /* "cannot happen" */
 
1027
                        return NULL;            /* "cannot happen" */
1024
1028
                result = localsub(&newt, offset, tmp, tz);
1025
1029
                if (result == tmp)
1026
1030
                {
1027
 
                        pg_time_t newy;
 
1031
                        pg_time_t       newy;
1028
1032
 
1029
1033
                        newy = tmp->tm_year;
1030
1034
                        if (t < sp->ats[0])
1031
1035
                                newy -= icycles * YEARSPERREPEAT;
1032
 
                        else    newy += icycles * YEARSPERREPEAT;
 
1036
                        else
 
1037
                                newy += icycles * YEARSPERREPEAT;
1033
1038
                        tmp->tm_year = newy;
1034
1039
                        if (tmp->tm_year != newy)
1035
1040
                                return NULL;
1048
1053
        }
1049
1054
        else
1050
1055
        {
1051
 
                int    lo = 1;
1052
 
                int    hi = sp->timecnt;
1053
 
 
 
1056
                int                     lo = 1;
 
1057
                int                     hi = sp->timecnt;
 
1058
 
1054
1059
                while (lo < hi)
1055
1060
                {
1056
 
                        int    mid = (lo + hi) >> 1;
1057
 
 
 
1061
                        int                     mid = (lo + hi) >> 1;
 
1062
 
1058
1063
                        if (t < sp->ats[mid])
1059
1064
                                hi = mid;
1060
 
                        else    lo = mid + 1;
 
1065
                        else
 
1066
                                lo = mid + 1;
1061
1067
                }
1062
1068
                i = (int) sp->types[lo - 1];
1063
1069
        }
1081
1087
 * gmtsub is to gmtime as localsub is to localtime.
1082
1088
 */
1083
1089
static struct pg_tm *
1084
 
gmtsub(const pg_time_t *timep, long offset, struct pg_tm *tmp)
 
1090
gmtsub(const pg_time_t *timep, long offset, struct pg_tm * tmp)
1085
1091
{
1086
1092
        struct pg_tm *result;
1087
1093
 
1125
1131
 
1126
1132
static struct pg_tm *
1127
1133
timesub(const pg_time_t *timep, long offset,
1128
 
                const struct state *sp, struct pg_tm *tmp)
 
1134
                const struct state * sp, struct pg_tm * tmp)
1129
1135
{
1130
1136
        const struct lsinfo *lp;
1131
1137
        pg_time_t       tdays;
1132
 
        int                     idays;  /* unsigned would be so 2003 */
 
1138
        int                     idays;                  /* unsigned would be so 2003 */
1133
1139
        long            rem;
1134
1140
        int                     y;
1135
1141
        const int  *ip;
1169
1175
        rem = *timep - tdays * SECSPERDAY;
1170
1176
        while (tdays < 0 || tdays >= year_lengths[isleap(y)])
1171
1177
        {
1172
 
                int             newy;
 
1178
                int                     newy;
1173
1179
                pg_time_t       tdelta;
1174
 
                int             idelta;
1175
 
                int             leapdays;
1176
 
 
 
1180
                int                     idelta;
 
1181
                int                     leapdays;
 
1182
 
1177
1183
                tdelta = tdays / DAYSPERLYEAR;
1178
1184
                idelta = tdelta;
1179
1185
                if (tdelta - idelta >= 1 || idelta - tdelta >= 1)
1190
1196
                y = newy;
1191
1197
        }
1192
1198
        {
1193
 
                long   seconds;
1194
 
 
 
1199
                long            seconds;
 
1200
 
1195
1201
                seconds = tdays * SECSPERDAY + 0.5;
1196
1202
                tdays = seconds / SECSPERDAY;
1197
1203
                rem += seconds - tdays * SECSPERDAY;
1198
1204
        }
 
1205
 
1199
1206
        /*
1200
1207
         * Given the range, we can now fearlessly cast...
1201
1208
         */
1227
1234
        if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE))
1228
1235
                return NULL;
1229
1236
        tmp->tm_yday = idays;
 
1237
 
1230
1238
        /*
1231
1239
         * The "extra" mods below avoid overflow problems.
1232
1240
         */
1264
1272
static int
1265
1273
increment_overflow(int *number, int delta)
1266
1274
{
1267
 
        int     number0;
 
1275
        int                     number0;
1268
1276
 
1269
1277
        number0 = *number;
1270
1278
        *number += delta;
1330
1338
                pg_time_t       tcycles;
1331
1339
                int64           icycles;
1332
1340
                int                     result;
1333
 
                
 
1341
 
1334
1342
                if (t < sp->ats[0])
1335
1343
                        seconds = sp->ats[0] - t;
1336
 
                else    seconds = t - sp->ats[sp->timecnt - 1];
 
1344
                else
 
1345
                        seconds = t - sp->ats[sp->timecnt - 1];
1337
1346
                --seconds;
1338
1347
                tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
1339
1348
                ++tcycles;
1345
1354
                seconds *= AVGSECSPERYEAR;
1346
1355
                if (t < sp->ats[0])
1347
1356
                        newt += seconds;
1348
 
                else    newt -= seconds;
 
1357
                else
 
1358
                        newt -= seconds;
1349
1359
                if (newt < sp->ats[0] ||
1350
1360
                        newt > sp->ats[sp->timecnt - 1])
1351
 
                        return -1;    /* "cannot happen" */
 
1361
                        return -1;                      /* "cannot happen" */
1352
1362
 
1353
1363
                result = pg_next_dst_boundary(&newt, before_gmtoff,
1354
1364
                                                                          before_isdst,
1395
1405
        }
1396
1406
        /* Else search to find the containing segment */
1397
1407
        {
1398
 
                int    lo = 1;
1399
 
                int    hi = sp->timecnt;
1400
 
 
 
1408
                int                     lo = 1;
 
1409
                int                     hi = sp->timecnt;
 
1410
 
1401
1411
                while (lo < hi)
1402
1412
                {
1403
 
                        int    mid = (lo + hi) >> 1;
1404
 
 
 
1413
                        int                     mid = (lo + hi) >> 1;
 
1414
 
1405
1415
                        if (t < sp->ats[mid])
1406
1416
                                hi = mid;
1407
 
                        else    lo = mid + 1;
 
1417
                        else
 
1418
                                lo = mid + 1;
1408
1419
                }
1409
1420
                i = lo;
1410
1421
        }