Annotation of parser3/src/types/pa_vdate.C, revision 1.9
1.1 moko 1: /** @file
2: Parser: @b date parser class.
3:
4: Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
5: */
6:
7: #include "pa_vstateless_object.h"
8: #include "pa_vdate.h"
9: #include "pa_vint.h"
10: #include "pa_vstring.h"
11:
1.9 ! moko 12: volatile const char * IDENT_PA_PA_VDATE_C="$Id: pa_vdate.C,v 1.8 2015/09/22 22:25:55 moko Exp $" IDENT_PA_VDATE_H;
1.1 moko 13:
1.4 moko 14: #define ZERO_DATE (-62169984000ll-SECS_PER_DAY) // '0000-00-00 00:00:00' - 1 day
15: #define MAX_DATE (253402300799ll+SECS_PER_DAY) // '9999-12-31 23:59:59' + 1 day
1.3 moko 16:
17: #define MAX_32_DATE 2147483647
18:
19: static const int DAYS_IN_MONTH[12] =
20: {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
21:
22: static const int DAYS_BEFORE_MONTH[12] =
23: {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
24:
25: #define IS_LEAP(y) (((y) % 4) == 0 && (((y) % 100) != 0 || (((y)+1900) % 400) == 0))
26:
27: int VDate::getMonthDays(int year, int month) {
28: return (month == 1 /* january -- 0 */ && IS_LEAP(year)) ? 29 : DAYS_IN_MONTH[month];
29: }
30:
31: static void pa_gmtime(pa_time_t lcltime, struct tm *res);
32: static pa_time_t pa_mktime(struct tm *tim_p);
33:
34: static int gmt_offset() {
35: #if defined(HAVE_TIMEZONE)
36: tzset();
1.6 moko 37: return -timezone;
1.3 moko 38: #else
39: time_t t=time(0);
40: tm *tm=localtime(&t);
41: #if defined(HAVE_TM_GMTOFF)
1.6 moko 42: return tm->tm_gmtoff;
1.3 moko 43: #elif defined(HAVE_TM_TZADJ)
1.6 moko 44: return -tm->tm_tzadj;
1.3 moko 45: #else
46: #error neither HAVE_TIMEZONE nor HAVE_TM_GMTOFF nor HAVE_TM_TZADJ defined
47: #endif
48: #endif
49: }
50:
51: static void pa_set_tz(const char* ntz) {
52: if(ntz && *ntz){
53: static char temp_tz_pair[MAX_STRING];
54: snprintf(temp_tz_pair, sizeof(temp_tz_pair), "TZ=%s", ntz);
55: putenv(temp_tz_pair);
56: } else {
1.1 moko 57: #ifdef HAVE_UNSETENV
1.3 moko 58: unsetenv("TZ");
1.1 moko 59: #else
1.3 moko 60: putenv("TZ=");
1.1 moko 61: #endif
1.3 moko 62: }
1.9 ! moko 63: tzset(); // required in Windows
1.1 moko 64: }
65:
1.3 moko 66: /// Auto-object used for temporarily substituting/removing timezone variable
67: class Temp_tz {
68: const char* ntz;
69: char saved_tz[MAX_STRING];
70: public:
71: static const char *default_tz;
72: public:
73: Temp_tz(const char *atz) : ntz(atz) {
74: if(!ntz)
75: ntz=default_tz;
76: if(!ntz)
77: return;
78: if(const char* ctz=getenv("TZ")){
79: strncpy(saved_tz, ctz, sizeof(saved_tz)-1);
80: } else
81: saved_tz[0]=0;
82: pa_set_tz(ntz);
83: }
84: ~Temp_tz() {
85: if(ntz)
86: pa_set_tz(saved_tz);
87: }
88: };
89:
90: const char *Temp_tz::default_tz=0;
1.1 moko 91:
1.8 moko 92: static void pa_localtime(const char *tz, pa_time_t atime, struct tm &tmIn) {
1.3 moko 93: Temp_tz temp_tz(tz);
94: #ifdef PA_DATE64
95: tmIn=*localtime(&atime);
96: #else
97: if(atime >= 0 && atime <= MAX_32_DATE){
1.5 moko 98: time_t itime=(time_t)atime;
1.3 moko 99: tmIn=*localtime(&itime);
100: } else {
1.6 moko 101: pa_gmtime(atime+gmt_offset(), &tmIn);
1.3 moko 102: }
103: #endif
1.1 moko 104: }
105:
1.3 moko 106: static pa_time_t pa_mktime(const char *tz, struct tm &tmIn) {
107: Temp_tz temp_tz(tz);
108: #ifdef PA_DATE64
109: return mktime(&tmIn);
110: #else
111: time_t result=mktime(&tmIn);
112: if(result != -1)
113: return result;
1.6 moko 114: return pa_mktime(&tmIn)-gmt_offset();
1.3 moko 115: #endif
1.1 moko 116: }
117:
1.3 moko 118: const String* VDate::get_sql_string(sql_string_type format) {
119: switch(format){
120: case sql_string_datetime:{
121: static const char *format="%.4d-%.2d-%.2d %.2d:%.2d:%.2d";
122: static int size=4+1+2+1+2 +1+ 2+1+2+1+2 +1/*zero-teminator*/+1/*for faulty snprintfs*/;
123: char *buf=new(PointerFreeGC) char[size];
124: snprintf(buf, size, format, ftm.tm_year+1900, ftm.tm_mon+1, ftm.tm_mday, ftm.tm_hour, ftm.tm_min, ftm.tm_sec);
125: return new String(buf);
126: }
127: case sql_string_date:{
128: static const char *format="%.4d-%.2d-%.2d";
129: static int size=4+1+2+1+2 +1/*zero-teminator*/+1/*for faulty snprintfs*/;
130: char *buf=new(PointerFreeGC) char[size];
131: snprintf(buf, size, format, ftm.tm_year+1900, ftm.tm_mon+1, ftm.tm_mday);
132: return new String(buf);
133: }
134: case sql_string_time:{
135: static const char *format="%.2d:%.2d:%.2d";
136: static int size=2+1+2+1+2 +1/*zero-teminator*/+1/*for faulty snprintfs*/;
137: char *buf=new(PointerFreeGC) char[size];
138: snprintf(buf, size, format, ftm.tm_hour, ftm.tm_min, ftm.tm_sec);
139: return new String(buf);
140: }
1.1 moko 141: }
1.3 moko 142: }
143:
144:
145: const String* VDate::get_gmt_string() {
1.6 moko 146: struct tm gtm;
1.3 moko 147: #ifdef PA_DATE64
1.6 moko 148: gtm=*gmtime(&ftime);
1.3 moko 149: #else
1.6 moko 150: pa_gmtime(ftime, >m);
1.3 moko 151: #endif
152: /// http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3
153: static const char month_names[12][4]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
154: static const char days[7][4]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
1.1 moko 155:
1.6 moko 156: static const char *format="%s, %.2d %s %.4d %.2d:%.2d:%.2d GMT";
1.3 moko 157: static int size=3+1+1+2+1+3+1+4+1+2+1+2+1+2+4 +1/*zero-teminator*/+1/*for faulty snprintfs*/;
158: char *buf=new(PointerFreeGC) char[size];
1.6 moko 159: snprintf(buf, size, format, days[gtm.tm_wday], gtm.tm_mday, month_names[gtm.tm_mon], gtm.tm_year+1900, gtm.tm_hour, gtm.tm_min, gtm.tm_sec);
1.3 moko 160: return new String(buf);
1.1 moko 161: }
162:
1.6 moko 163: const String* VDate::get_iso_string() {
164: Temp_tz temp_tz(ftz_cstr);
165: /// http://www.w3.org/TR/NOTE-datetime
166: if(int offset=gmt_offset()){
167: char sign=offset>0 ? '+':'-';
168: offset=abs(offset);
169: static const char *format="%.4d-%.2d-%.2dT%.2d:%.2d:%.2d%c%d:%.2d";
170: static int size=4+1+2+1+2 +1+ 2+1+2+1+2 +1+2+1+2 +1/*zero-teminator*/+1/*for faulty snprintfs*/;
171: char *buf=new(PointerFreeGC) char[size];
172: snprintf(buf, size, format, ftm.tm_year+1900, ftm.tm_mon+1, ftm.tm_mday, ftm.tm_hour, ftm.tm_min, ftm.tm_sec,
173: sign, offset/3600, (offset/60)%60);
174: return new String(buf);
175: } else {
176: static const char *format="%.4d-%.2d-%.2dT%.2d:%.2d:%.2dZ";
177: static int size=4+1+2+1+2 +1+ 2+1+2+1+2 +1 +1/*zero-teminator*/+1/*for faulty snprintfs*/;
178: char *buf=new(PointerFreeGC) char[size];
179: snprintf(buf, size, format, ftm.tm_year+1900, ftm.tm_mon+1, ftm.tm_mday, ftm.tm_hour, ftm.tm_min, ftm.tm_sec);
180: return new String(buf);
181: }
182: }
183:
1.1 moko 184: override Value* VDate::get_element(const String& aname) {
185: // $method
186: if(Value* result=VStateless_object::get_element(aname))
187: return result;
188:
189: // $TZ
1.3 moko 190: if(aname=="TZ")
191: return ftz_cstr ? new VString(*new String(ftz_cstr)): new VString();
1.1 moko 192:
193: int result;
1.3 moko 194: if(aname=="year") result=1900+ftm.tm_year;
195: else if(aname=="month") result=1+ftm.tm_mon;
196: else if(aname=="day") result=ftm.tm_mday;
197: else if(aname=="hour") result=ftm.tm_hour;
198: else if(aname=="minute") result=ftm.tm_min;
199: else if(aname=="second") result=ftm.tm_sec;
200: else if(aname=="weekday") result=ftm.tm_wday;
201: else if(aname=="yearday") result=ftm.tm_yday;
202: else if(aname=="daylightsaving") result=ftm.tm_isdst;
1.1 moko 203: else if(aname=="week") {
1.3 moko 204: yw week = CalcWeek(ftm);
1.1 moko 205: result=week.week;
206: }
207: else if(aname=="weekyear") {
1.3 moko 208: yw week = CalcWeek(ftm);
1.1 moko 209: result=1900+week.year;
210: } else { return bark("%s field not found", &aname); }
211: return new VInt(result);
212: }
213:
214: const String* VDate::get_json_string(Json_options& options) {
215: String* result=new String();
216: switch(options.date){
217: case Json_options::D_SQL:
218: result->append_quoted(get_sql_string());
219: break;
220: case Json_options::D_GMT:
221: result->append_quoted(get_gmt_string());
222: break;
1.6 moko 223: case Json_options::D_ISO:
224: result->append_quoted(get_iso_string());
225: break;
1.1 moko 226: case Json_options::D_TIMESTAMP:
227: *result << format((int)ftime, 0);
228: break;
229: }
230: return result;
231: }
1.2 moko 232:
1.3 moko 233: void VDate::validate() {
234: if((ftm.tm_year==-1901) && (ftm.tm_mon==10) && (ftm.tm_mday==30)){
235: ftm.tm_year=-1900;
236: ftm.tm_mon=-1;
237: ftm.tm_mday=0;
238: }
239: if((ftm.tm_year+1900)<0 || (ftm.tm_year+1900)>9999){
240: throw Exception(DATE_RANGE_EXCEPTION_TYPE, 0, "year '%d' is out of range 0..9999", ftm.tm_year+1900);
241: }
242: }
243:
244: void VDate::set_time(pa_time_t atime) {
1.2 moko 245: if(atime==-1)
246: throw Exception(DATE_RANGE_EXCEPTION_TYPE, 0, "invalid datetime");
1.3 moko 247: if(atime<ZERO_DATE || atime>MAX_DATE)
248: throw Exception(DATE_RANGE_EXCEPTION_TYPE, 0, "unix time %.15g is out of range 0..9999 year", (double)atime);
1.2 moko 249: ftime=atime;
1.3 moko 250: pa_localtime(ftz_cstr, ftime, ftm);
251: validate();
252: }
253:
254: void VDate::set_tm(tm &tmIn) {
1.4 moko 255: pa_time_t atime=pa_mktime(ftz_cstr, tmIn);
256: if(atime==-1)
257: throw Exception(DATE_RANGE_EXCEPTION_TYPE, 0, "invalid datetime '%04d-%02d-%02d'", tmIn.tm_year+1900, tmIn.tm_mon+1, tmIn.tm_mday);
258: ftime=atime;
1.3 moko 259: ftm=tmIn;
260: validate();
1.2 moko 261: }
262:
1.6 moko 263: void VDate::set_tz(const char* atz) {
264: ftz_cstr=atz && atz[0] ? atz : 0; // ftm should be updated afterwards
1.3 moko 265: }
266:
1.6 moko 267: void VDate::set_default_tz(const char* atz) {
268: Temp_tz::default_tz=atz && atz[0] ? atz : 0;
1.2 moko 269: }
270:
271: static int ISOWeekCount (int year) {
272: static const unsigned int YearWeeks[] = {
273: 52,52,52,52,53, 52,52,52,52,52,
274: 53,52,52,52,52, 52,53,52,52,52,
275: 52,53,52,52,52, 52,52,53
276: };
277: return YearWeeks[(year+1900) % 28];
278: }
279:
280: VDate::yw VDate::CalcWeek(tm& tms) {
281: yw week = {tms.tm_year, 0};
282:
283: // http://www.merlyn.demon.co.uk/weekinfo.htm
284: static const unsigned int FirstThurs[] = {7,5,4,3,2,7,6,5,4,2,1,7,6,4,3,2,1,6,5,4,3,1,7,6,5,3,2,1};
285: int diff = tms.tm_yday-(FirstThurs[(tms.tm_year+1900) % 28]-4);
286: if (diff < 0){
287: tms.tm_mday = diff;
1.3 moko 288: pa_mktime(0, tms); // normalize
1.2 moko 289: week = CalcWeek(tms);
290: } else {
291: week.week = 1 + diff/7;
292: if ( week.week > 52 && ISOWeekCount(week.year) < week.week ){
293: week.year++;
294: week.week = 1;
295: }
296: }
297: return week;
298: }
1.3 moko 299:
300: #ifndef PA_DATE64
301:
302: /*
303: * gmtime_r.c
304: * Original Author: Adapted from tzcode maintained by Arthur David Olson.
305: * Modifications:
306: * - Changed to mktm_r and added __tzcalc_limits - 04/10/02, Jeff Johnston
307: * - Fixed bug in mday computations - 08/12/04, Alex Mogilnikov <alx@intellectronika.ru>
308: * - Fixed bug in __tzcalc_limits - 08/12/04, Alex Mogilnikov <alx@intellectronika.ru>
309: * - Move code from _mktm_r() to gmtime_r() - 05/09/14, Freddie Chopin <freddie_chopin@op.pl>
310: * - Fixed bug in calculations for dates after year 2069 or before year 1901. Ideas for
311: * solution taken from musl's __secs_to_tm() - 07/12/2014, Freddie Chopin
312: * <freddie_chopin@op.pl>
313: * - Use faster algorithm from civil_from_days() by Howard Hinnant - 12/06/2014,
314: * Freddie Chopin <freddie_chopin@op.pl>
315: *
316: * Converts the calendar time pointed to by tim_p into a broken-down time
317: * expressed as local time. Returns a pointer to a structure containing the
318: * broken-down time.
319: */
320:
321: /* Move epoch from 01.01.1970 to 01.03.0000 (yes, Year 0) - this is the first
322: * day of a 400-year long "era", right after additional day of leap year.
323: * This adjustment is required only for date calculation, so instead of
324: * modifying time_t value (which would require 64-bit operations to work
325: * correctly) it's enough to adjust the calculated number of days since epoch.
326: */
327:
328: #define SECS_PER_HOUR 3600
329: #define SECS_PER_MIN 60
330: #define DAYS_PER_WEEK 7
331: #define YEAR_BASE 1900
332:
333: #define EPOCH_ADJUSTMENT_DAYS 719468L
334: /* year to which the adjustment was made */
335: #define ADJUSTED_EPOCH_YEAR 0
336: /* 1st March of year 0 is Wednesday */
337: #define ADJUSTED_EPOCH_WDAY 3
338: /* there are 97 leap years in 400-year periods. ((400 - 97) * 365 + 97 * 366) */
339: #define DAYS_PER_ERA 146097L
340: /* there are 24 leap years in 100-year periods. ((100 - 24) * 365 + 24 * 366) */
341: #define DAYS_PER_CENTURY 36524L
342: /* there is one leap year every 4 years */
343: #define DAYS_PER_4_YEARS (3 * 365 + 366)
344: /* number of days in a non-leap year */
345: #define DAYS_PER_YEAR 365
346: /* number of days in January */
347: #define DAYS_IN_JANUARY 31
348: /* number of days in non-leap February */
349: #define DAYS_IN_FEBRUARY 28
350: /* number of years per era */
351: #define YEARS_PER_ERA 400
352:
353: static void pa_gmtime(pa_time_t lcltime, struct tm *res) {
354: long days, rem;
355: int era, weekday, year;
356: unsigned erayear, yearday, month, day;
357: unsigned long eraday;
358:
1.5 moko 359: days = (long)(lcltime / SECS_PER_DAY);
360: rem = (long)(lcltime - (pa_time_t)days * SECS_PER_DAY);
1.3 moko 361: days += EPOCH_ADJUSTMENT_DAYS;
362: if (rem < 0)
363: {
364: rem += SECS_PER_DAY;
365: --days;
366: }
367:
368: /* compute hour, min, and sec */
369: res->tm_hour = (int) (rem / SECS_PER_HOUR);
370: rem %= SECS_PER_HOUR;
371: res->tm_min = (int) (rem / SECS_PER_MIN);
372: res->tm_sec = (int) (rem % SECS_PER_MIN);
373:
374: /* compute day of week */
375: if ((weekday = ((ADJUSTED_EPOCH_WDAY + days) % DAYS_PER_WEEK)) < 0)
376: weekday += DAYS_PER_WEEK;
377: res->tm_wday = weekday;
378:
379: /* compute year, month, day & day of year */
380: /* for description of this algorithm see
381: * http://howardhinnant.github.io/date_algorithms.html#civil_from_days */
382: era = (days >= 0 ? days : days - (DAYS_PER_ERA - 1)) / DAYS_PER_ERA;
383: eraday = days - era * DAYS_PER_ERA; /* [0, 146096] */
384: erayear = (eraday - eraday / (DAYS_PER_4_YEARS - 1) + eraday / DAYS_PER_CENTURY -
385: eraday / (DAYS_PER_ERA - 1)) / 365; /* [0, 399] */
386: yearday = eraday - (DAYS_PER_YEAR * erayear + erayear / 4 - erayear / 100); /* [0, 365] */
387: month = (5 * yearday + 2) / 153; /* [0, 11] */
388: day = yearday - (153 * month + 2) / 5 + 1; /* [1, 31] */
389: month += month < 10 ? 2 : -10;
390: year = ADJUSTED_EPOCH_YEAR + erayear + era * YEARS_PER_ERA + (month <= 1);
391:
392: res->tm_yday = yearday >= DAYS_PER_YEAR - DAYS_IN_JANUARY - DAYS_IN_FEBRUARY ?
393: yearday - (DAYS_PER_YEAR - DAYS_IN_JANUARY - DAYS_IN_FEBRUARY) :
394: yearday + DAYS_IN_JANUARY + DAYS_IN_FEBRUARY + IS_LEAP(erayear);
395: res->tm_year = year - YEAR_BASE;
396: res->tm_mon = month;
397: res->tm_mday = day;
398:
399: res->tm_isdst = 0;
400: }
401:
402:
403: /*
404: * mktime.c
405: * Original Author: G. Haley
406: *
407: * Converts the broken-down time, expressed as local time, in the structure
408: * pointed to by tim_p into a calendar time value. The original values of the
409: * tm_wday and tm_yday fields of the structure are ignored, and the original
410: * values of the other fields have no restrictions. On successful completion
411: * the fields of the structure are set to represent the specified calendar
412: * time. Returns the specified calendar time. If the calendar time can not be
413: * represented, returns the value (time_t) -1.
414: */
415:
416: #define _DAYS_IN_MONTH(x) ((x == 1) ? days_in_feb : DAYS_IN_MONTH[x])
417: #define _DAYS_IN_YEAR(year) (IS_LEAP(year) ? 366 : 365)
418:
419: static void validate_structure(struct tm *tim_p) {
420: div_t res;
421: int days_in_feb = 28;
422:
423: /* calculate time & date to account for out of range values */
424: if (tim_p->tm_sec < 0 || tim_p->tm_sec > 59)
425: {
426: res = div (tim_p->tm_sec, 60);
427: tim_p->tm_min += res.quot;
428: if ((tim_p->tm_sec = res.rem) < 0)
429: {
430: tim_p->tm_sec += 60;
431: --tim_p->tm_min;
432: }
433: }
434:
435: if (tim_p->tm_min < 0 || tim_p->tm_min > 59)
436: {
437: res = div (tim_p->tm_min, 60);
438: tim_p->tm_hour += res.quot;
439: if ((tim_p->tm_min = res.rem) < 0)
440: {
441: tim_p->tm_min += 60;
442: --tim_p->tm_hour;
443: }
444: }
445:
446: if (tim_p->tm_hour < 0 || tim_p->tm_hour > 23)
447: {
448: res = div (tim_p->tm_hour, 24);
449: tim_p->tm_mday += res.quot;
450: if ((tim_p->tm_hour = res.rem) < 0)
451: {
452: tim_p->tm_hour += 24;
453: --tim_p->tm_mday;
454: }
455: }
456:
457: if (tim_p->tm_mon < 0 || tim_p->tm_mon > 11)
458: {
459: res = div (tim_p->tm_mon, 12);
460: tim_p->tm_year += res.quot;
461: if ((tim_p->tm_mon = res.rem) < 0)
462: {
463: tim_p->tm_mon += 12;
464: --tim_p->tm_year;
465: }
466: }
467:
468: if (_DAYS_IN_YEAR (tim_p->tm_year) == 366)
469: days_in_feb = 29;
470:
471: if (tim_p->tm_mday <= 0)
472: {
473: while (tim_p->tm_mday <= 0)
474: {
475: if (--tim_p->tm_mon == -1)
476: {
477: tim_p->tm_year--;
478: tim_p->tm_mon = 11;
479: days_in_feb =
480: ((_DAYS_IN_YEAR (tim_p->tm_year) == 366) ?
481: 29 : 28);
482: }
483: tim_p->tm_mday += _DAYS_IN_MONTH (tim_p->tm_mon);
484: }
485: }
486: else
487: {
488: while (tim_p->tm_mday > _DAYS_IN_MONTH (tim_p->tm_mon))
489: {
490: tim_p->tm_mday -= _DAYS_IN_MONTH (tim_p->tm_mon);
491: if (++tim_p->tm_mon == 12)
492: {
493: tim_p->tm_year++;
494: tim_p->tm_mon = 0;
495: days_in_feb =
496: ((_DAYS_IN_YEAR (tim_p->tm_year) == 366) ?
497: 29 : 28);
498: }
499: }
500: }
501: }
502:
503: static pa_time_t pa_mktime(struct tm *tim_p) {
504: pa_time_t tim = 0;
505: long days = 0;
506: int year;
507:
508: /* validate structure */
509: validate_structure (tim_p);
510:
511: /* compute hours, minutes, seconds */
512: tim += tim_p->tm_sec + (tim_p->tm_min * SECS_PER_MIN) +
513: (tim_p->tm_hour * SECS_PER_HOUR);
514:
515: /* compute days in year */
516: days += tim_p->tm_mday - 1;
517: days += DAYS_BEFORE_MONTH[tim_p->tm_mon];
518: if (tim_p->tm_mon > 1 && _DAYS_IN_YEAR (tim_p->tm_year) == 366)
519: days++;
520:
521: /* compute day of the year */
522: tim_p->tm_yday = days;
523:
524: if (tim_p->tm_year > 10000 || tim_p->tm_year < -10000)
525: return (time_t) -1;
526:
527: /* compute days in other years */
528: if ((year = tim_p->tm_year) > 70)
529: {
530: for (year = 70; year < tim_p->tm_year; year++)
531: days += _DAYS_IN_YEAR (year);
532: }
533: else if (year < 70)
534: {
535: for (year = 69; year > tim_p->tm_year; year--)
536: days -= _DAYS_IN_YEAR (year);
537: days -= _DAYS_IN_YEAR (year);
538: }
539:
540: /* compute total seconds */
541: tim += (pa_time_t)days * SECS_PER_DAY;
542:
543: /* compute day of the week */
544: if ((tim_p->tm_wday = (days + 4) % 7) < 0)
545: tim_p->tm_wday += 7;
546:
547: return tim;
548: }
549:
550: #endif
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pa_vdate.C CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / types