Annotation of embedaddon/php/ext/date/lib/parse_tz.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2010 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Derick Rethans <derick@derickrethans.nl> |
! 16: +----------------------------------------------------------------------+
! 17: */
! 18:
! 19: /* $Id: parse_tz.c 311110 2011-05-16 21:29:45Z johannes $ */
! 20:
! 21: #include "timelib.h"
! 22:
! 23: #include <stdio.h>
! 24:
! 25: #ifdef HAVE_LOCALE_H
! 26: #include <locale.h>
! 27: #endif
! 28:
! 29: #ifdef HAVE_STRING_H
! 30: #include <string.h>
! 31: #else
! 32: #include <strings.h>
! 33: #endif
! 34: #include "timezonedb.h"
! 35:
! 36: #if (defined(__APPLE__) || defined(__APPLE_CC__)) && (defined(__BIG_ENDIAN__) || defined(__LITTLE_ENDIAN__))
! 37: # if defined(__LITTLE_ENDIAN__)
! 38: # undef WORDS_BIGENDIAN
! 39: # else
! 40: # if defined(__BIG_ENDIAN__)
! 41: # define WORDS_BIGENDIAN
! 42: # endif
! 43: # endif
! 44: #endif
! 45:
! 46: #ifdef WORDS_BIGENDIAN
! 47: #define timelib_conv_int(l) (l)
! 48: #else
! 49: #define timelib_conv_int(l) ((l & 0x000000ff) << 24) + ((l & 0x0000ff00) << 8) + ((l & 0x00ff0000) >> 8) + ((l & 0xff000000) >> 24)
! 50: #endif
! 51:
! 52: static void read_preamble(const unsigned char **tzf, timelib_tzinfo *tz)
! 53: {
! 54: /* skip ID */
! 55: *tzf += 4;
! 56:
! 57: /* read BC flag */
! 58: tz->bc = (**tzf == '\1');
! 59: *tzf += 1;
! 60:
! 61: /* read country code */
! 62: memcpy(tz->location.country_code, *tzf, 2);
! 63: tz->location.country_code[2] = '\0';
! 64: *tzf += 2;
! 65:
! 66: /* skip read of preamble */
! 67: *tzf += 13;
! 68: }
! 69:
! 70: static void read_header(const unsigned char **tzf, timelib_tzinfo *tz)
! 71: {
! 72: uint32_t buffer[6];
! 73:
! 74: memcpy(&buffer, *tzf, sizeof(buffer));
! 75: tz->ttisgmtcnt = timelib_conv_int(buffer[0]);
! 76: tz->ttisstdcnt = timelib_conv_int(buffer[1]);
! 77: tz->leapcnt = timelib_conv_int(buffer[2]);
! 78: tz->timecnt = timelib_conv_int(buffer[3]);
! 79: tz->typecnt = timelib_conv_int(buffer[4]);
! 80: tz->charcnt = timelib_conv_int(buffer[5]);
! 81: *tzf += sizeof(buffer);
! 82: }
! 83:
! 84: static void read_transistions(const unsigned char **tzf, timelib_tzinfo *tz)
! 85: {
! 86: int32_t *buffer = NULL;
! 87: uint32_t i;
! 88: unsigned char *cbuffer = NULL;
! 89:
! 90: if (tz->timecnt) {
! 91: buffer = (int32_t*) malloc(tz->timecnt * sizeof(int32_t));
! 92: if (!buffer) {
! 93: return;
! 94: }
! 95: memcpy(buffer, *tzf, sizeof(int32_t) * tz->timecnt);
! 96: *tzf += (sizeof(int32_t) * tz->timecnt);
! 97: for (i = 0; i < tz->timecnt; i++) {
! 98: buffer[i] = timelib_conv_int(buffer[i]);
! 99: }
! 100:
! 101: cbuffer = (unsigned char*) malloc(tz->timecnt * sizeof(unsigned char));
! 102: if (!cbuffer) {
! 103: free(buffer);
! 104: return;
! 105: }
! 106: memcpy(cbuffer, *tzf, sizeof(unsigned char) * tz->timecnt);
! 107: *tzf += sizeof(unsigned char) * tz->timecnt;
! 108: }
! 109:
! 110: tz->trans = buffer;
! 111: tz->trans_idx = cbuffer;
! 112: }
! 113:
! 114: static void read_types(const unsigned char **tzf, timelib_tzinfo *tz)
! 115: {
! 116: unsigned char *buffer;
! 117: int32_t *leap_buffer;
! 118: unsigned int i, j;
! 119:
! 120: buffer = (unsigned char*) malloc(tz->typecnt * sizeof(unsigned char) * 6);
! 121: if (!buffer) {
! 122: return;
! 123: }
! 124: memcpy(buffer, *tzf, sizeof(unsigned char) * 6 * tz->typecnt);
! 125: *tzf += sizeof(unsigned char) * 6 * tz->typecnt;
! 126:
! 127: tz->type = (ttinfo*) malloc(tz->typecnt * sizeof(struct ttinfo));
! 128: if (!tz->type) {
! 129: free(buffer);
! 130: return;
! 131: }
! 132:
! 133: for (i = 0; i < tz->typecnt; i++) {
! 134: j = i * 6;
! 135: tz->type[i].offset = (buffer[j] * 16777216) + (buffer[j + 1] * 65536) + (buffer[j + 2] * 256) + buffer[j + 3];
! 136: tz->type[i].isdst = buffer[j + 4];
! 137: tz->type[i].abbr_idx = buffer[j + 5];
! 138: }
! 139: free(buffer);
! 140:
! 141: tz->timezone_abbr = (char*) malloc(tz->charcnt);
! 142: if (!tz->timezone_abbr) {
! 143: return;
! 144: }
! 145: memcpy(tz->timezone_abbr, *tzf, sizeof(char) * tz->charcnt);
! 146: *tzf += sizeof(char) * tz->charcnt;
! 147:
! 148: if (tz->leapcnt) {
! 149: leap_buffer = (int32_t *) malloc(tz->leapcnt * 2 * sizeof(int32_t));
! 150: if (!leap_buffer) {
! 151: return;
! 152: }
! 153: memcpy(leap_buffer, *tzf, sizeof(int32_t) * tz->leapcnt * 2);
! 154: *tzf += sizeof(int32_t) * tz->leapcnt * 2;
! 155:
! 156: tz->leap_times = (tlinfo*) malloc(tz->leapcnt * sizeof(tlinfo));
! 157: if (!tz->leap_times) {
! 158: free(leap_buffer);
! 159: return;
! 160: }
! 161: for (i = 0; i < tz->leapcnt; i++) {
! 162: tz->leap_times[i].trans = timelib_conv_int(leap_buffer[i * 2]);
! 163: tz->leap_times[i].offset = timelib_conv_int(leap_buffer[i * 2 + 1]);
! 164: }
! 165: free(leap_buffer);
! 166: }
! 167:
! 168: if (tz->ttisstdcnt) {
! 169: buffer = (unsigned char*) malloc(tz->ttisstdcnt * sizeof(unsigned char));
! 170: if (!buffer) {
! 171: return;
! 172: }
! 173: memcpy(buffer, *tzf, sizeof(unsigned char) * tz->ttisstdcnt);
! 174: *tzf += sizeof(unsigned char) * tz->ttisstdcnt;
! 175:
! 176: for (i = 0; i < tz->ttisstdcnt; i++) {
! 177: tz->type[i].isstdcnt = buffer[i];
! 178: }
! 179: free(buffer);
! 180: }
! 181:
! 182: if (tz->ttisgmtcnt) {
! 183: buffer = (unsigned char*) malloc(tz->ttisgmtcnt * sizeof(unsigned char));
! 184: if (!buffer) {
! 185: return;
! 186: }
! 187: memcpy(buffer, *tzf, sizeof(unsigned char) * tz->ttisgmtcnt);
! 188: *tzf += sizeof(unsigned char) * tz->ttisgmtcnt;
! 189:
! 190: for (i = 0; i < tz->ttisgmtcnt; i++) {
! 191: tz->type[i].isgmtcnt = buffer[i];
! 192: }
! 193: free(buffer);
! 194: }
! 195: }
! 196:
! 197: static void read_location(const unsigned char **tzf, timelib_tzinfo *tz)
! 198: {
! 199: uint32_t buffer[3];
! 200: uint32_t comments_len;
! 201:
! 202: memcpy(&buffer, *tzf, sizeof(buffer));
! 203: tz->location.latitude = timelib_conv_int(buffer[0]);
! 204: tz->location.latitude = (tz->location.latitude / 100000) - 90;
! 205: tz->location.longitude = timelib_conv_int(buffer[1]);
! 206: tz->location.longitude = (tz->location.longitude / 100000) - 180;
! 207: comments_len = timelib_conv_int(buffer[2]);
! 208: *tzf += sizeof(buffer);
! 209:
! 210: tz->location.comments = malloc(comments_len + 1);
! 211: memcpy(tz->location.comments, *tzf, comments_len);
! 212: tz->location.comments[comments_len] = '\0';
! 213: *tzf += comments_len;
! 214: }
! 215:
! 216: void timelib_dump_tzinfo(timelib_tzinfo *tz)
! 217: {
! 218: uint32_t i;
! 219:
! 220: printf("Country Code: %s\n", tz->location.country_code);
! 221: printf("Geo Location: %f,%f\n", tz->location.latitude, tz->location.longitude);
! 222: printf("Comments:\n%s\n", tz->location.comments);
! 223: printf("BC: %s\n", tz->bc ? "" : "yes");
! 224: printf("UTC/Local count: %lu\n", (unsigned long) tz->ttisgmtcnt);
! 225: printf("Std/Wall count: %lu\n", (unsigned long) tz->ttisstdcnt);
! 226: printf("Leap.sec. count: %lu\n", (unsigned long) tz->leapcnt);
! 227: printf("Trans. count: %lu\n", (unsigned long) tz->timecnt);
! 228: printf("Local types count: %lu\n", (unsigned long) tz->typecnt);
! 229: printf("Zone Abbr. count: %lu\n", (unsigned long) tz->charcnt);
! 230:
! 231: printf ("%8s (%12s) = %3d [%5ld %1d %3d '%s' (%d,%d)]\n",
! 232: "", "", 0,
! 233: (long int) tz->type[0].offset,
! 234: tz->type[0].isdst,
! 235: tz->type[0].abbr_idx,
! 236: &tz->timezone_abbr[tz->type[0].abbr_idx],
! 237: tz->type[0].isstdcnt,
! 238: tz->type[0].isgmtcnt
! 239: );
! 240: for (i = 0; i < tz->timecnt; i++) {
! 241: printf ("%08X (%12d) = %3d [%5ld %1d %3d '%s' (%d,%d)]\n",
! 242: tz->trans[i], tz->trans[i], tz->trans_idx[i],
! 243: (long int) tz->type[tz->trans_idx[i]].offset,
! 244: tz->type[tz->trans_idx[i]].isdst,
! 245: tz->type[tz->trans_idx[i]].abbr_idx,
! 246: &tz->timezone_abbr[tz->type[tz->trans_idx[i]].abbr_idx],
! 247: tz->type[tz->trans_idx[i]].isstdcnt,
! 248: tz->type[tz->trans_idx[i]].isgmtcnt
! 249: );
! 250: }
! 251: for (i = 0; i < tz->leapcnt; i++) {
! 252: printf ("%08X (%12ld) = %d\n",
! 253: tz->leap_times[i].trans,
! 254: (long) tz->leap_times[i].trans,
! 255: tz->leap_times[i].offset);
! 256: }
! 257: }
! 258:
! 259: static int seek_to_tz_position(const unsigned char **tzf, char *timezone, const timelib_tzdb *tzdb)
! 260: {
! 261: int left = 0, right = tzdb->index_size - 1;
! 262: #ifdef HAVE_SETLOCALE
! 263: char *cur_locale = NULL, *tmp;
! 264:
! 265: tmp = setlocale(LC_CTYPE, NULL);
! 266: if (tmp) {
! 267: cur_locale = strdup(tmp);
! 268: }
! 269: setlocale(LC_CTYPE, "C");
! 270: #endif
! 271:
! 272: do {
! 273: int mid = ((unsigned)left + right) >> 1;
! 274: int cmp = strcasecmp(timezone, tzdb->index[mid].id);
! 275:
! 276: if (cmp < 0) {
! 277: right = mid - 1;
! 278: } else if (cmp > 0) {
! 279: left = mid + 1;
! 280: } else { /* (cmp == 0) */
! 281: (*tzf) = &(tzdb->data[tzdb->index[mid].pos]);
! 282: #ifdef HAVE_SETLOCALE
! 283: setlocale(LC_CTYPE, cur_locale);
! 284: if (cur_locale) free(cur_locale);
! 285: #endif
! 286: return 1;
! 287: }
! 288:
! 289: } while (left <= right);
! 290:
! 291: #ifdef HAVE_SETLOCALE
! 292: setlocale(LC_CTYPE, cur_locale);
! 293: if (cur_locale) free(cur_locale);
! 294: #endif
! 295: return 0;
! 296: }
! 297:
! 298: const timelib_tzdb *timelib_builtin_db(void)
! 299: {
! 300: return &timezonedb_builtin;
! 301: }
! 302:
! 303: const timelib_tzdb_index_entry *timelib_timezone_builtin_identifiers_list(int *count)
! 304: {
! 305: *count = sizeof(timezonedb_idx_builtin) / sizeof(*timezonedb_idx_builtin);
! 306: return timezonedb_idx_builtin;
! 307: }
! 308:
! 309: int timelib_timezone_id_is_valid(char *timezone, const timelib_tzdb *tzdb)
! 310: {
! 311: const unsigned char *tzf;
! 312: return (seek_to_tz_position(&tzf, timezone, tzdb));
! 313: }
! 314:
! 315: timelib_tzinfo *timelib_parse_tzfile(char *timezone, const timelib_tzdb *tzdb)
! 316: {
! 317: const unsigned char *tzf;
! 318: timelib_tzinfo *tmp;
! 319:
! 320: if (seek_to_tz_position(&tzf, timezone, tzdb)) {
! 321: tmp = timelib_tzinfo_ctor(timezone);
! 322:
! 323: read_preamble(&tzf, tmp);
! 324: read_header(&tzf, tmp);
! 325: read_transistions(&tzf, tmp);
! 326: read_types(&tzf, tmp);
! 327: read_location(&tzf, tmp);
! 328: } else {
! 329: tmp = NULL;
! 330: }
! 331:
! 332: return tmp;
! 333: }
! 334:
! 335: static ttinfo* fetch_timezone_offset(timelib_tzinfo *tz, timelib_sll ts, timelib_sll *transition_time)
! 336: {
! 337: uint32_t i;
! 338:
! 339: /* If there is no transistion time, we pick the first one, if that doesn't
! 340: * exist we return NULL */
! 341: if (!tz->timecnt || !tz->trans) {
! 342: *transition_time = 0;
! 343: if (tz->typecnt == 1) {
! 344: return &(tz->type[0]);
! 345: }
! 346: return NULL;
! 347: }
! 348:
! 349: /* If the TS is lower than the first transistion time, then we scan over
! 350: * all the transistion times to find the first non-DST one, or the first
! 351: * one in case there are only DST entries. Not sure which smartass came up
! 352: * with this idea in the first though :) */
! 353: if (ts < tz->trans[0]) {
! 354: uint32_t j;
! 355:
! 356: *transition_time = 0;
! 357: j = 0;
! 358: while (j < tz->timecnt && tz->type[j].isdst) {
! 359: ++j;
! 360: }
! 361: if (j == tz->timecnt) {
! 362: j = 0;
! 363: }
! 364: return &(tz->type[j]);
! 365: }
! 366:
! 367: /* In all other cases we loop through the available transtion times to find
! 368: * the correct entry */
! 369: for (i = 0; i < tz->timecnt; i++) {
! 370: if (ts < tz->trans[i]) {
! 371: *transition_time = tz->trans[i - 1];
! 372: return &(tz->type[tz->trans_idx[i - 1]]);
! 373: }
! 374: }
! 375: *transition_time = tz->trans[tz->timecnt - 1];
! 376: return &(tz->type[tz->trans_idx[tz->timecnt - 1]]);
! 377: }
! 378:
! 379: static tlinfo* fetch_leaptime_offset(timelib_tzinfo *tz, timelib_sll ts)
! 380: {
! 381: int i;
! 382:
! 383: if (!tz->leapcnt || !tz->leap_times) {
! 384: return NULL;
! 385: }
! 386:
! 387: for (i = tz->leapcnt - 1; i > 0; i--) {
! 388: if (ts > tz->leap_times[i].trans) {
! 389: return &(tz->leap_times[i]);
! 390: }
! 391: }
! 392: return NULL;
! 393: }
! 394:
! 395: int timelib_timestamp_is_in_dst(timelib_sll ts, timelib_tzinfo *tz)
! 396: {
! 397: ttinfo *to;
! 398: timelib_sll dummy;
! 399:
! 400: if ((to = fetch_timezone_offset(tz, ts, &dummy))) {
! 401: return to->isdst;
! 402: }
! 403: return -1;
! 404: }
! 405:
! 406: timelib_time_offset *timelib_get_time_zone_info(timelib_sll ts, timelib_tzinfo *tz)
! 407: {
! 408: ttinfo *to;
! 409: tlinfo *tl;
! 410: int32_t offset = 0, leap_secs = 0;
! 411: char *abbr;
! 412: timelib_time_offset *tmp = timelib_time_offset_ctor();
! 413: timelib_sll transistion_time;
! 414:
! 415: if ((to = fetch_timezone_offset(tz, ts, &transistion_time))) {
! 416: offset = to->offset;
! 417: abbr = &(tz->timezone_abbr[to->abbr_idx]);
! 418: tmp->is_dst = to->isdst;
! 419: tmp->transistion_time = transistion_time;
! 420: } else {
! 421: offset = 0;
! 422: abbr = tz->timezone_abbr;
! 423: tmp->is_dst = 0;
! 424: tmp->transistion_time = 0;
! 425: }
! 426:
! 427: if ((tl = fetch_leaptime_offset(tz, ts))) {
! 428: leap_secs = -tl->offset;
! 429: }
! 430:
! 431: tmp->offset = offset;
! 432: tmp->leap_secs = leap_secs;
! 433: tmp->abbr = abbr ? strdup(abbr) : strdup("GMT");
! 434:
! 435: return tmp;
! 436: }
! 437:
! 438: timelib_sll timelib_get_current_offset(timelib_time *t)
! 439: {
! 440: timelib_time_offset *gmt_offset;
! 441: timelib_sll retval;
! 442:
! 443: switch (t->zone_type) {
! 444: case TIMELIB_ZONETYPE_ABBR:
! 445: case TIMELIB_ZONETYPE_OFFSET:
! 446: return (t->z + t->dst) * -60;
! 447:
! 448: case TIMELIB_ZONETYPE_ID:
! 449: gmt_offset = timelib_get_time_zone_info(t->sse, t->tz_info);
! 450: retval = gmt_offset->offset;
! 451: timelib_time_offset_dtor(gmt_offset);
! 452: return retval;
! 453:
! 454: default:
! 455: return 0;
! 456: }
! 457: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parse_tz.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / date / lib