xref: /PHP-5.6/ext/date/lib/timelib.c (revision f43f6fc3)
1 /*
2  * The MIT License (MIT)
3  *
4  * Copyright (c) 2015 Derick Rethans
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 
25 #include "timelib.h"
26 #include <ctype.h>
27 #include <math.h>
28 
29 #define TIMELIB_TIME_FREE(m) 	\
30 	if (m) {		\
31 		timelib_free(m);	\
32 		m = NULL;	\
33 	}			\
34 
35 #define TIMELIB_LLABS(y) (y < 0 ? (y * -1) : y)
36 
37 #define HOUR(a) (int)(a * 60)
38 
timelib_time_ctor(void)39 timelib_time* timelib_time_ctor(void)
40 {
41 	timelib_time *t;
42 	t = timelib_calloc(1, sizeof(timelib_time));
43 
44 	return t;
45 }
46 
timelib_rel_time_ctor(void)47 timelib_rel_time* timelib_rel_time_ctor(void)
48 {
49 	timelib_rel_time *t;
50 	t = timelib_calloc(1, sizeof(timelib_rel_time));
51 
52 	return t;
53 }
54 
timelib_time_clone(timelib_time * orig)55 timelib_time* timelib_time_clone(timelib_time *orig)
56 {
57 	timelib_time *tmp = timelib_time_ctor();
58 	memcpy(tmp, orig, sizeof(timelib_time));
59 	if (orig->tz_abbr) {
60 		tmp->tz_abbr = timelib_strdup(orig->tz_abbr);
61 	}
62 	if (orig->tz_info) {
63 		tmp->tz_info = orig->tz_info;
64 	}
65 	return tmp;
66 }
67 
timelib_time_compare(timelib_time * t1,timelib_time * t2)68 int timelib_time_compare(timelib_time *t1, timelib_time *t2)
69 {
70 	if (t1->sse == t2->sse) {
71 		if (t1->f == t2->f) {
72 			return 0;
73 		}
74 
75 		if (t1->sse < 0) {
76 			return (t1->f < t2->f) ? 1 : -1;
77 		} else {
78 			return (t1->f < t2->f) ? -1 : 1;
79 		}
80 	}
81 
82 	return (t1->sse < t2->sse) ? -1 : 1;
83 }
84 
timelib_rel_time_clone(timelib_rel_time * rel)85 timelib_rel_time* timelib_rel_time_clone(timelib_rel_time *rel)
86 {
87 	timelib_rel_time *tmp = timelib_rel_time_ctor();
88 	memcpy(tmp, rel, sizeof(timelib_rel_time));
89 	return tmp;
90 }
91 
timelib_time_tz_abbr_update(timelib_time * tm,char * tz_abbr)92 void timelib_time_tz_abbr_update(timelib_time* tm, char* tz_abbr)
93 {
94 	unsigned int i;
95 	size_t tz_abbr_len = strlen(tz_abbr);
96 
97 	TIMELIB_TIME_FREE(tm->tz_abbr);
98 	tm->tz_abbr = timelib_strdup(tz_abbr);
99 	for (i = 0; i < tz_abbr_len; i++) {
100 		tm->tz_abbr[i] = toupper(tz_abbr[i]);
101 	}
102 }
103 
timelib_time_dtor(timelib_time * t)104 void timelib_time_dtor(timelib_time* t)
105 {
106 	TIMELIB_TIME_FREE(t->tz_abbr);
107 	TIMELIB_TIME_FREE(t);
108 }
109 
timelib_rel_time_dtor(timelib_rel_time * t)110 void timelib_rel_time_dtor(timelib_rel_time* t)
111 {
112 	TIMELIB_TIME_FREE(t);
113 }
114 
timelib_time_offset_ctor(void)115 timelib_time_offset* timelib_time_offset_ctor(void)
116 {
117 	timelib_time_offset *t;
118 	t = timelib_calloc(1, sizeof(timelib_time_offset));
119 
120 	return t;
121 }
122 
timelib_time_offset_dtor(timelib_time_offset * t)123 void timelib_time_offset_dtor(timelib_time_offset* t)
124 {
125 	TIMELIB_TIME_FREE(t->abbr);
126 	TIMELIB_TIME_FREE(t);
127 }
128 
timelib_tzinfo_ctor(char * name)129 timelib_tzinfo* timelib_tzinfo_ctor(char *name)
130 {
131 	timelib_tzinfo *t;
132 	t = timelib_calloc(1, sizeof(timelib_tzinfo));
133 	t->name = timelib_strdup(name);
134 
135 	return t;
136 }
137 
timelib_tzinfo_clone(timelib_tzinfo * tz)138 timelib_tzinfo *timelib_tzinfo_clone(timelib_tzinfo *tz)
139 {
140 	timelib_tzinfo *tmp = timelib_tzinfo_ctor(tz->name);
141 	tmp->bit32.ttisgmtcnt = tz->bit32.ttisgmtcnt;
142 	tmp->bit32.ttisstdcnt = tz->bit32.ttisstdcnt;
143 	tmp->bit32.leapcnt = tz->bit32.leapcnt;
144 	tmp->bit32.timecnt = tz->bit32.timecnt;
145 	tmp->bit32.typecnt = tz->bit32.typecnt;
146 	tmp->bit32.charcnt = tz->bit32.charcnt;
147 
148 	tmp->trans = (int32_t *) timelib_malloc(tz->bit32.timecnt * sizeof(int32_t));
149 	tmp->trans_idx = (unsigned char*) timelib_malloc(tz->bit32.timecnt * sizeof(unsigned char));
150 	memcpy(tmp->trans, tz->trans, tz->bit32.timecnt * sizeof(int32_t));
151 	memcpy(tmp->trans_idx, tz->trans_idx, tz->bit32.timecnt * sizeof(unsigned char));
152 
153 	tmp->type = (ttinfo*) timelib_malloc(tz->bit32.typecnt * sizeof(struct ttinfo));
154 	memcpy(tmp->type, tz->type, tz->bit32.typecnt * sizeof(struct ttinfo));
155 
156 	tmp->timezone_abbr = (char*) timelib_malloc(tz->bit32.charcnt);
157 	memcpy(tmp->timezone_abbr, tz->timezone_abbr, tz->bit32.charcnt);
158 
159 	tmp->leap_times = (tlinfo*) timelib_malloc(tz->bit32.leapcnt * sizeof(tlinfo));
160 	memcpy(tmp->leap_times, tz->leap_times, tz->bit32.leapcnt * sizeof(tlinfo));
161 
162 	return tmp;
163 }
164 
timelib_tzinfo_dtor(timelib_tzinfo * tz)165 void timelib_tzinfo_dtor(timelib_tzinfo *tz)
166 {
167 	TIMELIB_TIME_FREE(tz->name);
168 	TIMELIB_TIME_FREE(tz->trans);
169 	TIMELIB_TIME_FREE(tz->trans_idx);
170 	TIMELIB_TIME_FREE(tz->type);
171 	TIMELIB_TIME_FREE(tz->timezone_abbr);
172 	TIMELIB_TIME_FREE(tz->leap_times);
173 	TIMELIB_TIME_FREE(tz->location.comments);
174 	TIMELIB_TIME_FREE(tz);
175 	tz = NULL;
176 }
177 
timelib_get_tz_abbr_ptr(timelib_time * t)178 char *timelib_get_tz_abbr_ptr(timelib_time *t)
179 {
180 	if (!t->sse_uptodate) {
181 		timelib_update_ts(t, NULL);
182 	};
183 	return t->tz_abbr;
184 }
185 
timelib_error_container_dtor(timelib_error_container * errors)186 void timelib_error_container_dtor(timelib_error_container *errors)
187 {
188 	int i;
189 
190 	for (i = 0; i < errors->warning_count; i++) {
191 		timelib_free(errors->warning_messages[i].message);
192 	}
193 	timelib_free(errors->warning_messages);
194 	for (i = 0; i < errors->error_count; i++) {
195 		timelib_free(errors->error_messages[i].message);
196 	}
197 	timelib_free(errors->error_messages);
198 	timelib_free(errors);
199 }
200 
timelib_date_to_int(timelib_time * d,int * error)201 timelib_long timelib_date_to_int(timelib_time *d, int *error)
202 {
203 	timelib_sll ts;
204 
205 	ts = d->sse;
206 
207 	if (ts < TIMELIB_LONG_MIN || ts > TIMELIB_LONG_MAX) {
208 		if (error) {
209 			*error = 1;
210 		}
211 		return 0;
212 	}
213 	if (error) {
214 		*error = 0;
215 	}
216 	return (timelib_long) d->sse;
217 }
218 
timelib_decimal_hour_to_hms(double h,int * hour,int * min,int * sec)219 void timelib_decimal_hour_to_hms(double h, int *hour, int *min, int *sec)
220 {
221 	*hour = floor(h);
222 	*min =  floor((h - *hour) * 60);
223 	*sec =  (h - *hour - ((float) *min / 60)) * 3600;
224 }
225 
timelib_dump_date(timelib_time * d,int options)226 void timelib_dump_date(timelib_time *d, int options)
227 {
228 	if ((options & 2) == 2) {
229 		printf("TYPE: %d ", d->zone_type);
230 	}
231 	printf("TS: %lld | %s%04lld-%02lld-%02lld %02lld:%02lld:%02lld",
232 		d->sse, d->y < 0 ? "-" : "", TIMELIB_LLABS(d->y), d->m, d->d, d->h, d->i, d->s);
233 	if (d->f > +0.0) {
234 		printf(" %.5f", d->f);
235 	}
236 
237 	if (d->is_localtime) {
238 		switch (d->zone_type) {
239 			case TIMELIB_ZONETYPE_OFFSET: /* Only offset */
240 				printf(" GMT %05d%s", d->z, d->dst == 1 ? " (DST)" : "");
241 				break;
242 			case TIMELIB_ZONETYPE_ID: /* Timezone struct */
243 				/* Show abbreviation if wanted */
244 				if (d->tz_abbr) {
245 					printf(" %s", d->tz_abbr);
246 				}
247 				/* Do we have a TimeZone struct? */
248 				if (d->tz_info) {
249 					printf(" %s", d->tz_info->name);
250 				}
251 				break;
252 			case TIMELIB_ZONETYPE_ABBR:
253 				printf(" %s", d->tz_abbr);
254 				printf(" %05d%s", d->z, d->dst == 1 ? " (DST)" : "");
255 				break;
256 		}
257 	}
258 
259 	if ((options & 1) == 1) {
260 		if (d->have_relative) {
261 			printf("%3lldY %3lldM %3lldD / %3lldH %3lldM %3lldS",
262 				d->relative.y, d->relative.m, d->relative.d, d->relative.h, d->relative.i, d->relative.s);
263 			if (d->relative.first_last_day_of != 0) {
264 				switch (d->relative.first_last_day_of) {
265 					case 1:
266 						printf(" / first day of");
267 						break;
268 					case 2:
269 						printf(" / last day of");
270 						break;
271 				}
272 			}
273 			if (d->relative.have_weekday_relative) {
274 				printf(" / %d.%d", d->relative.weekday, d->relative.weekday_behavior);
275 			}
276 			if (d->relative.have_special_relative) {
277 				switch (d->relative.special.type) {
278 					case TIMELIB_SPECIAL_WEEKDAY:
279 						printf(" / %lld weekday", d->relative.special.amount);
280 						break;
281 					case TIMELIB_SPECIAL_DAY_OF_WEEK_IN_MONTH:
282 						printf(" / x y of z month");
283 						break;
284 					case TIMELIB_SPECIAL_LAST_DAY_OF_WEEK_IN_MONTH:
285 						printf(" / last y of z month");
286 						break;
287 				}
288 			}
289 		}
290 	}
291 	printf("\n");
292 }
293 
timelib_dump_rel_time(timelib_rel_time * d)294 void timelib_dump_rel_time(timelib_rel_time *d)
295 {
296 	printf("%3lldY %3lldM %3lldD / %3lldH %3lldM %3lldS (days: %lld)%s",
297 		d->y, d->m, d->d, d->h, d->i, d->s, d->days, d->invert ? " inverted" : "");
298 	if (d->first_last_day_of != 0) {
299 		switch (d->first_last_day_of) {
300 			case 1:
301 				printf(" / first day of");
302 				break;
303 			case 2:
304 				printf(" / last day of");
305 				break;
306 		}
307 	}
308 	printf("\n");
309 }
310 
timelib_parse_tz_cor(char ** ptr)311 timelib_long timelib_parse_tz_cor(char **ptr)
312 {
313 	char *begin = *ptr, *end;
314 	timelib_long  tmp;
315 
316 	while (isdigit(**ptr) || **ptr == ':') {
317 		++*ptr;
318 	}
319 	end = *ptr;
320 	switch (end - begin) {
321 		case 1: /* H */
322 		case 2: /* HH */
323 			return HOUR(strtol(begin, NULL, 10));
324 			break;
325 		case 3: /* H:M */
326 		case 4: /* H:MM, HH:M, HHMM */
327 			if (begin[1] == ':') {
328 				tmp = HOUR(strtol(begin, NULL, 10)) + strtol(begin + 2, NULL, 10);
329 				return tmp;
330 			} else if (begin[2] == ':') {
331 				tmp = HOUR(strtol(begin, NULL, 10)) + strtol(begin + 3, NULL, 10);
332 				return tmp;
333 			} else {
334 				tmp = strtol(begin, NULL, 10);
335 				return HOUR(tmp / 100) + tmp % 100;
336 			}
337 		case 5: /* HH:MM */
338 			tmp = HOUR(strtol(begin, NULL, 10)) + strtol(begin + 3, NULL, 10);
339 			return tmp;
340 	}
341 	return 0;
342 }
343