Skip to content

Commit a1fef89

Browse files
derickrderickr
committed
Merge branch 'PHP-5.5' into PHP-5.6
2 parents 43c6944 + 912e42f commit a1fef89

File tree

3 files changed

+124
-100
lines changed

3 files changed

+124
-100
lines changed

‎ext/date/lib/parse_tz.c

Lines changed: 88 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -77,20 +77,20 @@ static void read_header(const unsigned char **tzf, timelib_tzinfo *tz)
7777
uint32_t buffer[6];
7878

7979
memcpy(&buffer, *tzf, sizeof(buffer));
80-
tz->ttisgmtcnt = timelib_conv_int(buffer[0]);
81-
tz->ttisstdcnt = timelib_conv_int(buffer[1]);
82-
tz->leapcnt = timelib_conv_int(buffer[2]);
83-
tz->timecnt = timelib_conv_int(buffer[3]);
84-
tz->typecnt = timelib_conv_int(buffer[4]);
85-
tz->charcnt = timelib_conv_int(buffer[5]);
80+
tz->bit32.ttisgmtcnt = timelib_conv_int(buffer[0]);
81+
tz->bit32.ttisstdcnt = timelib_conv_int(buffer[1]);
82+
tz->bit32.leapcnt = timelib_conv_int(buffer[2]);
83+
tz->bit32.timecnt = timelib_conv_int(buffer[3]);
84+
tz->bit32.typecnt = timelib_conv_int(buffer[4]);
85+
tz->bit32.charcnt = timelib_conv_int(buffer[5]);
8686
*tzf += sizeof(buffer);
8787
}
8888

89-
static void skip_transistions_64bit(const unsigned char **tzf, timelib_tzinfo *tz)
89+
static void skip_64bit_transistions(const unsigned char **tzf, timelib_tzinfo *tz)
9090
{
91-
if (tz->timecnt) {
92-
*tzf += (sizeof(int64_t) * (tz->timecnt + 1));
93-
*tzf += (sizeof(unsigned char) * (tz->timecnt + 1));
91+
if (tz->bit64.timecnt) {
92+
*tzf += (sizeof(int64_t) * tz->bit64.timecnt);
93+
*tzf += (sizeof(unsigned char) * tz->bit64.timecnt);
9494
}
9595
}
9696

@@ -100,42 +100,42 @@ static void read_transistions(const unsigned char **tzf, timelib_tzinfo *tz)
100100
uint32_t i;
101101
unsigned char *cbuffer = NULL;
102102

103-
if (tz->timecnt) {
104-
buffer = (int32_t*) malloc(tz->timecnt * sizeof(int32_t));
103+
if (tz->bit32.timecnt) {
104+
buffer = (int32_t*) malloc(tz->bit32.timecnt * sizeof(int32_t));
105105
if (!buffer) {
106106
return;
107107
}
108-
memcpy(buffer, *tzf, sizeof(int32_t) * tz->timecnt);
109-
*tzf += (sizeof(int32_t) * tz->timecnt);
110-
for (i = 0; i < tz->timecnt; i++) {
108+
memcpy(buffer, *tzf, sizeof(int32_t) * tz->bit32.timecnt);
109+
*tzf += (sizeof(int32_t) * tz->bit32.timecnt);
110+
for (i = 0; i < tz->bit32.timecnt; i++) {
111111
buffer[i] = timelib_conv_int(buffer[i]);
112112
}
113113

114-
cbuffer = (unsigned char*) malloc(tz->timecnt * sizeof(unsigned char));
114+
cbuffer = (unsigned char*) malloc(tz->bit32.timecnt * sizeof(unsigned char));
115115
if (!cbuffer) {
116116
free(buffer);
117117
return;
118118
}
119-
memcpy(cbuffer, *tzf, sizeof(unsigned char) * tz->timecnt);
120-
*tzf += sizeof(unsigned char) * tz->timecnt;
119+
memcpy(cbuffer, *tzf, sizeof(unsigned char) * tz->bit32.timecnt);
120+
*tzf += sizeof(unsigned char) * tz->bit32.timecnt;
121121
}
122122

123123
tz->trans = buffer;
124124
tz->trans_idx = cbuffer;
125125
}
126126

127-
static void skip_types_64bit(const unsigned char **tzf, timelib_tzinfo *tz)
127+
static void skip_64bit_types(const unsigned char **tzf, timelib_tzinfo *tz)
128128
{
129-
*tzf += sizeof(unsigned char) * 6 * tz->typecnt;
130-
*tzf += sizeof(char) * tz->charcnt;
131-
if (tz->leapcnt) {
132-
*tzf += sizeof(int64_t) * tz->leapcnt * 2;
129+
*tzf += sizeof(unsigned char) * 6 * tz->bit64.typecnt;
130+
*tzf += sizeof(char) * tz->bit64.charcnt;
131+
if (tz->bit64.leapcnt) {
132+
*tzf += sizeof(int64_t) * tz->bit64.leapcnt * 2;
133133
}
134-
if (tz->ttisstdcnt) {
135-
*tzf += sizeof(unsigned char) * tz->ttisstdcnt;
134+
if (tz->bit64.ttisstdcnt) {
135+
*tzf += sizeof(unsigned char) * tz->bit64.ttisstdcnt;
136136
}
137-
if (tz->ttisgmtcnt) {
138-
*tzf += sizeof(unsigned char) * tz->ttisgmtcnt;
137+
if (tz->bit64.ttisgmtcnt) {
138+
*tzf += sizeof(unsigned char) * tz->bit64.ttisgmtcnt;
139139
}
140140
}
141141

@@ -145,77 +145,77 @@ static void read_types(const unsigned char **tzf, timelib_tzinfo *tz)
145145
int32_t *leap_buffer;
146146
unsigned int i, j;
147147

148-
buffer = (unsigned char*) malloc(tz->typecnt * sizeof(unsigned char) * 6);
148+
buffer = (unsigned char*) malloc(tz->bit32.typecnt * sizeof(unsigned char) * 6);
149149
if (!buffer) {
150150
return;
151151
}
152-
memcpy(buffer, *tzf, sizeof(unsigned char) * 6 * tz->typecnt);
153-
*tzf += sizeof(unsigned char) * 6 * tz->typecnt;
152+
memcpy(buffer, *tzf, sizeof(unsigned char) * 6 * tz->bit32.typecnt);
153+
*tzf += sizeof(unsigned char) * 6 * tz->bit32.typecnt;
154154

155-
tz->type = (ttinfo*) malloc(tz->typecnt * sizeof(struct ttinfo));
155+
tz->type = (ttinfo*) malloc(tz->bit32.typecnt * sizeof(struct ttinfo));
156156
if (!tz->type) {
157157
free(buffer);
158158
return;
159159
}
160160

161-
for (i = 0; i < tz->typecnt; i++) {
161+
for (i = 0; i < tz->bit32.typecnt; i++) {
162162
j = i * 6;
163163
tz->type[i].offset = (buffer[j] * 16777216) + (buffer[j + 1] * 65536) + (buffer[j + 2] * 256) + buffer[j + 3];
164164
tz->type[i].isdst = buffer[j + 4];
165165
tz->type[i].abbr_idx = buffer[j + 5];
166166
}
167167
free(buffer);
168168

169-
tz->timezone_abbr = (char*) malloc(tz->charcnt);
169+
tz->timezone_abbr = (char*) malloc(tz->bit32.charcnt);
170170
if (!tz->timezone_abbr) {
171171
return;
172172
}
173-
memcpy(tz->timezone_abbr, *tzf, sizeof(char) * tz->charcnt);
174-
*tzf += sizeof(char) * tz->charcnt;
173+
memcpy(tz->timezone_abbr, *tzf, sizeof(char) * tz->bit32.charcnt);
174+
*tzf += sizeof(char) * tz->bit32.charcnt;
175175

176-
if (tz->leapcnt) {
177-
leap_buffer = (int32_t *) malloc(tz->leapcnt * 2 * sizeof(int32_t));
176+
if (tz->bit32.leapcnt) {
177+
leap_buffer = (int32_t *) malloc(tz->bit32.leapcnt * 2 * sizeof(int32_t));
178178
if (!leap_buffer) {
179179
return;
180180
}
181-
memcpy(leap_buffer, *tzf, sizeof(int32_t) * tz->leapcnt * 2);
182-
*tzf += sizeof(int32_t) * tz->leapcnt * 2;
181+
memcpy(leap_buffer, *tzf, sizeof(int32_t) * tz->bit32.leapcnt * 2);
182+
*tzf += sizeof(int32_t) * tz->bit32.leapcnt * 2;
183183

184-
tz->leap_times = (tlinfo*) malloc(tz->leapcnt * sizeof(tlinfo));
184+
tz->leap_times = (tlinfo*) malloc(tz->bit32.leapcnt * sizeof(tlinfo));
185185
if (!tz->leap_times) {
186186
free(leap_buffer);
187187
return;
188188
}
189-
for (i = 0; i < tz->leapcnt; i++) {
189+
for (i = 0; i < tz->bit32.leapcnt; i++) {
190190
tz->leap_times[i].trans = timelib_conv_int(leap_buffer[i * 2]);
191191
tz->leap_times[i].offset = timelib_conv_int(leap_buffer[i * 2 + 1]);
192192
}
193193
free(leap_buffer);
194194
}
195195

196-
if (tz->ttisstdcnt) {
197-
buffer = (unsigned char*) malloc(tz->ttisstdcnt * sizeof(unsigned char));
196+
if (tz->bit32.ttisstdcnt) {
197+
buffer = (unsigned char*) malloc(tz->bit32.ttisstdcnt * sizeof(unsigned char));
198198
if (!buffer) {
199199
return;
200200
}
201-
memcpy(buffer, *tzf, sizeof(unsigned char) * tz->ttisstdcnt);
202-
*tzf += sizeof(unsigned char) * tz->ttisstdcnt;
201+
memcpy(buffer, *tzf, sizeof(unsigned char) * tz->bit32.ttisstdcnt);
202+
*tzf += sizeof(unsigned char) * tz->bit32.ttisstdcnt;
203203

204-
for (i = 0; i < tz->ttisstdcnt; i++) {
204+
for (i = 0; i < tz->bit32.ttisstdcnt; i++) {
205205
tz->type[i].isstdcnt = buffer[i];
206206
}
207207
free(buffer);
208208
}
209209

210-
if (tz->ttisgmtcnt) {
211-
buffer = (unsigned char*) malloc(tz->ttisgmtcnt * sizeof(unsigned char));
210+
if (tz->bit32.ttisgmtcnt) {
211+
buffer = (unsigned char*) malloc(tz->bit32.ttisgmtcnt * sizeof(unsigned char));
212212
if (!buffer) {
213213
return;
214214
}
215-
memcpy(buffer, *tzf, sizeof(unsigned char) * tz->ttisgmtcnt);
216-
*tzf += sizeof(unsigned char) * tz->ttisgmtcnt;
215+
memcpy(buffer, *tzf, sizeof(unsigned char) * tz->bit32.ttisgmtcnt);
216+
*tzf += sizeof(unsigned char) * tz->bit32.ttisgmtcnt;
217217

218-
for (i = 0; i < tz->ttisgmtcnt; i++) {
218+
for (i = 0; i < tz->bit32.ttisgmtcnt; i++) {
219219
tz->type[i].isgmtcnt = buffer[i];
220220
}
221221
free(buffer);
@@ -261,12 +261,12 @@ void timelib_dump_tzinfo(timelib_tzinfo *tz)
261261
printf("Geo Location: %f,%f\n", tz->location.latitude, tz->location.longitude);
262262
printf("Comments:\n%s\n", tz->location.comments);
263263
printf("BC: %s\n", tz->bc ? "" : "yes");
264-
printf("UTC/Local count: %lu\n", (unsigned long) tz->ttisgmtcnt);
265-
printf("Std/Wall count: %lu\n", (unsigned long) tz->ttisstdcnt);
266-
printf("Leap.sec. count: %lu\n", (unsigned long) tz->leapcnt);
267-
printf("Trans. count: %lu\n", (unsigned long) tz->timecnt);
268-
printf("Local types count: %lu\n", (unsigned long) tz->typecnt);
269-
printf("Zone Abbr. count: %lu\n", (unsigned long) tz->charcnt);
264+
printf("UTC/Local count: " TIMELIB_ULONG_FMT "\n", (timelib_ulong) tz->bit32.ttisgmtcnt);
265+
printf("Std/Wall count: " TIMELIB_ULONG_FMT "\n", (timelib_ulong) tz->bit32.ttisstdcnt);
266+
printf("Leap.sec. count: " TIMELIB_ULONG_FMT "\n", (timelib_ulong) tz->bit32.leapcnt);
267+
printf("Trans. count: " TIMELIB_ULONG_FMT "\n", (timelib_ulong) tz->bit32.timecnt);
268+
printf("Local types count: " TIMELIB_ULONG_FMT "\n", (timelib_ulong) tz->bit32.typecnt);
269+
printf("Zone Abbr. count: " TIMELIB_ULONG_FMT "\n", (timelib_ulong) tz->bit32.charcnt);
270270

271271
printf ("%8s (%12s) = %3d [%5ld %1d %3d '%s' (%d,%d)]\n",
272272
"", "", 0,
@@ -277,7 +277,7 @@ void timelib_dump_tzinfo(timelib_tzinfo *tz)
277277
tz->type[0].isstdcnt,
278278
tz->type[0].isgmtcnt
279279
);
280-
for (i = 0; i < tz->timecnt; i++) {
280+
for (i = 0; i < tz->bit32.timecnt; i++) {
281281
printf ("%08X (%12d) = %3d [%5ld %1d %3d '%s' (%d,%d)]\n",
282282
tz->trans[i], tz->trans[i], tz->trans_idx[i],
283283
(long int) tz->type[tz->trans_idx[i]].offset,
@@ -288,7 +288,7 @@ void timelib_dump_tzinfo(timelib_tzinfo *tz)
288288
tz->type[tz->trans_idx[i]].isgmtcnt
289289
);
290290
}
291-
for (i = 0; i < tz->leapcnt; i++) {
291+
for (i = 0; i < tz->bit32.leapcnt; i++) {
292292
printf ("%08X (%12ld) = %d\n",
293293
tz->leap_times[i].trans,
294294
(long) tz->leap_times[i].trans,
@@ -352,10 +352,23 @@ int timelib_timezone_id_is_valid(char *timezone, const timelib_tzdb *tzdb)
352352
return (seek_to_tz_position(&tzf, timezone, tzdb));
353353
}
354354

355-
static void skip_2nd_header_and_data(const unsigned char **tzf, timelib_tzinfo *tz)
355+
static void skip_64bit_preamble(const unsigned char **tzf, timelib_tzinfo *tz)
356356
{
357-
*tzf += 20; /* skip 2nd header (preamble) */
358-
*tzf += sizeof(int32_t) * 6; /* Counts */
357+
*tzf += 20;
358+
}
359+
360+
static void read_64bit_header(const unsigned char **tzf, timelib_tzinfo *tz)
361+
{
362+
uint32_t buffer[6];
363+
364+
memcpy(&buffer, *tzf, sizeof(buffer));
365+
tz->bit64.ttisgmtcnt = timelib_conv_int(buffer[0]);
366+
tz->bit64.ttisstdcnt = timelib_conv_int(buffer[1]);
367+
tz->bit64.leapcnt = timelib_conv_int(buffer[2]);
368+
tz->bit64.timecnt = timelib_conv_int(buffer[3]);
369+
tz->bit64.typecnt = timelib_conv_int(buffer[4]);
370+
tz->bit64.charcnt = timelib_conv_int(buffer[5]);
371+
*tzf += sizeof(buffer);
359372
}
360373

361374
timelib_tzinfo *timelib_parse_tzfile(char *timezone, const timelib_tzdb *tzdb)
@@ -372,9 +385,10 @@ timelib_tzinfo *timelib_parse_tzfile(char *timezone, const timelib_tzdb *tzdb)
372385
read_transistions(&tzf, tmp);
373386
read_types(&tzf, tmp);
374387
if (version == 2) {
375-
skip_2nd_header_and_data(&tzf, tmp);
376-
skip_transistions_64bit(&tzf, tmp);
377-
skip_types_64bit(&tzf, tmp);
388+
skip_64bit_preamble(&tzf, tmp);
389+
read_64bit_header(&tzf, tmp);
390+
skip_64bit_transistions(&tzf, tmp);
391+
skip_64bit_types(&tzf, tmp);
378392
skip_posix_string(&tzf, tmp);
379393
}
380394
read_location(&tzf, tmp);
@@ -391,9 +405,9 @@ static ttinfo* fetch_timezone_offset(timelib_tzinfo *tz, timelib_sll ts, timelib
391405

392406
/* If there is no transition time, we pick the first one, if that doesn't
393407
* exist we return NULL */
394-
if (!tz->timecnt || !tz->trans) {
408+
if (!tz->bit32.timecnt || !tz->trans) {
395409
*transition_time = 0;
396-
if (tz->typecnt == 1) {
410+
if (tz->bit32.typecnt == 1) {
397411
return &(tz->type[0]);
398412
}
399413
return NULL;
@@ -408,36 +422,36 @@ static ttinfo* fetch_timezone_offset(timelib_tzinfo *tz, timelib_sll ts, timelib
408422

409423
*transition_time = 0;
410424
j = 0;
411-
while (j < tz->timecnt && tz->type[j].isdst) {
425+
while (j < tz->bit32.timecnt && tz->type[j].isdst) {
412426
++j;
413427
}
414-
if (j == tz->timecnt) {
428+
if (j == tz->bit32.timecnt) {
415429
j = 0;
416430
}
417431
return &(tz->type[j]);
418432
}
419433

420434
/* In all other cases we loop through the available transtion times to find
421435
* the correct entry */
422-
for (i = 0; i < tz->timecnt; i++) {
436+
for (i = 0; i < tz->bit32.timecnt; i++) {
423437
if (ts < tz->trans[i]) {
424438
*transition_time = tz->trans[i - 1];
425439
return &(tz->type[tz->trans_idx[i - 1]]);
426440
}
427441
}
428-
*transition_time = tz->trans[tz->timecnt - 1];
429-
return &(tz->type[tz->trans_idx[tz->timecnt - 1]]);
442+
*transition_time = tz->trans[tz->bit32.timecnt - 1];
443+
return &(tz->type[tz->trans_idx[tz->bit32.timecnt - 1]]);
430444
}
431445

432446
static tlinfo* fetch_leaptime_offset(timelib_tzinfo *tz, timelib_sll ts)
433447
{
434448
int i;
435449

436-
if (!tz->leapcnt || !tz->leap_times) {
450+
if (!tz->bit32.leapcnt || !tz->leap_times) {
437451
return NULL;
438452
}
439453

440-
for (i = tz->leapcnt - 1; i > 0; i--) {
454+
for (i = tz->bit32.leapcnt - 1; i > 0; i--) {
441455
if (ts > tz->leap_times[i].trans) {
442456
return &(tz->leap_times[i]);
443457
}

‎ext/date/lib/timelib.c

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -116,26 +116,26 @@ timelib_tzinfo* timelib_tzinfo_ctor(char *name)
116116
timelib_tzinfo *timelib_tzinfo_clone(timelib_tzinfo *tz)
117117
{
118118
timelib_tzinfo *tmp = timelib_tzinfo_ctor(tz->name);
119-
tmp->ttisgmtcnt = tz->ttisgmtcnt;
120-
tmp->ttisstdcnt = tz->ttisstdcnt;
121-
tmp->leapcnt = tz->leapcnt;
122-
tmp->timecnt = tz->timecnt;
123-
tmp->typecnt = tz->typecnt;
124-
tmp->charcnt = tz->charcnt;
125-
126-
tmp->trans = (int32_t *) malloc(tz->timecnt * sizeof(int32_t));
127-
tmp->trans_idx = (unsigned char*) malloc(tz->timecnt * sizeof(unsigned char));
128-
memcpy(tmp->trans, tz->trans, tz->timecnt * sizeof(int32_t));
129-
memcpy(tmp->trans_idx, tz->trans_idx, tz->timecnt * sizeof(unsigned char));
130-
131-
tmp->type = (ttinfo*) malloc(tz->typecnt * sizeof(struct ttinfo));
132-
memcpy(tmp->type, tz->type, tz->typecnt * sizeof(struct ttinfo));
133-
134-
tmp->timezone_abbr = (char*) malloc(tz->charcnt);
135-
memcpy(tmp->timezone_abbr, tz->timezone_abbr, tz->charcnt);
136-
137-
tmp->leap_times = (tlinfo*) malloc(tz->leapcnt * sizeof(tlinfo));
138-
memcpy(tmp->leap_times, tz->leap_times, tz->leapcnt * sizeof(tlinfo));
119+
tmp->bit32.ttisgmtcnt = tz->bit32.ttisgmtcnt;
120+
tmp->bit32.ttisstdcnt = tz->bit32.ttisstdcnt;
121+
tmp->bit32.leapcnt = tz->bit32.leapcnt;
122+
tmp->bit32.timecnt = tz->bit32.timecnt;
123+
tmp->bit32.typecnt = tz->bit32.typecnt;
124+
tmp->bit32.charcnt = tz->bit32.charcnt;
125+
126+
tmp->trans = (int32_t *) malloc(tz->bit32.timecnt * sizeof(int32_t));
127+
tmp->trans_idx = (unsigned char*) malloc(tz->bit32.timecnt * sizeof(unsigned char));
128+
memcpy(tmp->trans, tz->trans, tz->bit32.timecnt * sizeof(int32_t));
129+
memcpy(tmp->trans_idx, tz->trans_idx, tz->bit32.timecnt * sizeof(unsigned char));
130+
131+
tmp->type = (ttinfo*) malloc(tz->bit32.typecnt * sizeof(struct ttinfo));
132+
memcpy(tmp->type, tz->type, tz->bit32.typecnt * sizeof(struct ttinfo));
133+
134+
tmp->timezone_abbr = (char*) malloc(tz->bit32.charcnt);
135+
memcpy(tmp->timezone_abbr, tz->timezone_abbr, tz->bit32.charcnt);
136+
137+
tmp->leap_times = (tlinfo*) malloc(tz->bit32.leapcnt * sizeof(tlinfo));
138+
memcpy(tmp->leap_times, tz->leap_times, tz->bit32.leapcnt * sizeof(tlinfo));
139139

140140
return tmp;
141141
}

0 commit comments

Comments
 (0)