| /* |
| * date.c: Implementation of the EXSLT -- Dates and Times module |
| * |
| * References: |
| * http://www.exslt.org/date/date.html |
| * |
| * See Copyright for the status of this software. |
| * |
| * Authors: |
| * Charlie Bozeman <cbozeman@HiWAAY.net> |
| * Thomas Broyer <tbroyer@ltgt.net> |
| * |
| * TODO: |
| * elements: |
| * date-format |
| * functions: |
| * format-date |
| * parse-date |
| * sum |
| */ |
| |
| #define IN_LIBEXSLT |
| #include "libexslt/libexslt.h" |
| |
| #if defined(WIN32) && !defined (__CYGWIN__) && (!__MINGW32__) |
| #include <win32config.h> |
| #else |
| #include "config.h" |
| #endif |
| |
| #if defined(HAVE_LOCALTIME_R) && defined(__GLIBC__) /* _POSIX_SOURCE required by gnu libc */ |
| #ifndef _AIX51 /* but on AIX we're not using gnu libc */ |
| #define _POSIX_SOURCE |
| #endif |
| #endif |
| |
| #include <libxml/tree.h> |
| #include <libxml/xpath.h> |
| #include <libxml/xpathInternals.h> |
| |
| #include <libxslt/xsltconfig.h> |
| #include <libxslt/xsltutils.h> |
| #include <libxslt/xsltInternals.h> |
| #include <libxslt/extensions.h> |
| |
| #include "exslt.h" |
| |
| #include <string.h> |
| |
| #ifdef HAVE_MATH_H |
| #include <math.h> |
| #endif |
| |
| /* needed to get localtime_r on Solaris */ |
| #ifdef __sun |
| #ifndef __EXTENSIONS__ |
| #define __EXTENSIONS__ |
| #endif |
| #endif |
| |
| #ifdef HAVE_TIME_H |
| #include <time.h> |
| #endif |
| |
| /* |
| * types of date and/or time (from schema datatypes) |
| * somewhat ordered from least specific to most specific (i.e. |
| * most truncated to least truncated). |
| */ |
| typedef enum { |
| EXSLT_UNKNOWN = 0, |
| XS_TIME = 1, /* time is left-truncated */ |
| XS_GDAY = (XS_TIME << 1), |
| XS_GMONTH = (XS_GDAY << 1), |
| XS_GMONTHDAY = (XS_GMONTH | XS_GDAY), |
| XS_GYEAR = (XS_GMONTH << 1), |
| XS_GYEARMONTH = (XS_GYEAR | XS_GMONTH), |
| XS_DATE = (XS_GYEAR | XS_GMONTH | XS_GDAY), |
| XS_DATETIME = (XS_DATE | XS_TIME), |
| XS_DURATION = (XS_GYEAR << 1) |
| } exsltDateType; |
| |
| /* Date value */ |
| typedef struct _exsltDateValDate exsltDateValDate; |
| typedef exsltDateValDate *exsltDateValDatePtr; |
| struct _exsltDateValDate { |
| long year; |
| unsigned int mon :4; /* 1 <= mon <= 12 */ |
| unsigned int day :5; /* 1 <= day <= 31 */ |
| unsigned int hour :5; /* 0 <= hour <= 23 */ |
| unsigned int min :6; /* 0 <= min <= 59 */ |
| double sec; |
| unsigned int tz_flag :1; /* is tzo explicitely set? */ |
| signed int tzo :12; /* -1440 <= tzo <= 1440 currently only -840 to +840 are needed */ |
| }; |
| |
| /* Duration value */ |
| typedef struct _exsltDateValDuration exsltDateValDuration; |
| typedef exsltDateValDuration *exsltDateValDurationPtr; |
| struct _exsltDateValDuration { |
| long mon; /* mon stores years also */ |
| long day; |
| double sec; /* sec stores min and hour also */ |
| }; |
| |
| typedef struct _exsltDateVal exsltDateVal; |
| typedef exsltDateVal *exsltDateValPtr; |
| struct _exsltDateVal { |
| exsltDateType type; |
| union { |
| exsltDateValDate date; |
| exsltDateValDuration dur; |
| } value; |
| }; |
| |
| /**************************************************************** |
| * * |
| * Compat./Port. macros * |
| * * |
| ****************************************************************/ |
| |
| #if defined(HAVE_TIME_H) \ |
| && (defined(HAVE_LOCALTIME) || defined(HAVE_LOCALTIME_R)) \ |
| && (defined(HAVE_GMTIME) || defined(HAVE_GMTIME_R)) \ |
| && defined(HAVE_TIME) |
| #define WITH_TIME |
| #endif |
| |
| /**************************************************************** |
| * * |
| * Convenience macros and functions * |
| * * |
| ****************************************************************/ |
| |
| #define IS_TZO_CHAR(c) \ |
| ((c == 0) || (c == 'Z') || (c == '+') || (c == '-')) |
| |
| #define VALID_ALWAYS(num) (num >= 0) |
| #define VALID_YEAR(yr) (yr != 0) |
| #define VALID_MONTH(mon) ((mon >= 1) && (mon <= 12)) |
| /* VALID_DAY should only be used when month is unknown */ |
| #define VALID_DAY(day) ((day >= 1) && (day <= 31)) |
| #define VALID_HOUR(hr) ((hr >= 0) && (hr <= 23)) |
| #define VALID_MIN(min) ((min >= 0) && (min <= 59)) |
| #define VALID_SEC(sec) ((sec >= 0) && (sec < 60)) |
| #define VALID_TZO(tzo) ((tzo > -1440) && (tzo < 1440)) |
| #define IS_LEAP(y) \ |
| (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0)) |
| |
| static const unsigned long daysInMonth[12] = |
| { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; |
| static const unsigned long daysInMonthLeap[12] = |
| { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; |
| |
| #define MAX_DAYINMONTH(yr,mon) \ |
| (IS_LEAP(yr) ? daysInMonthLeap[mon - 1] : daysInMonth[mon - 1]) |
| |
| #define VALID_MDAY(dt) \ |
| (IS_LEAP(dt->year) ? \ |
| (dt->day <= daysInMonthLeap[dt->mon - 1]) : \ |
| (dt->day <= daysInMonth[dt->mon - 1])) |
| |
| #define VALID_DATE(dt) \ |
| (VALID_YEAR(dt->year) && VALID_MONTH(dt->mon) && VALID_MDAY(dt)) |
| |
| /* |
| hour and min structure vals are unsigned, so normal macros give |
| warnings on some compilers. |
| */ |
| #define VALID_TIME(dt) \ |
| ((dt->hour <=23 ) && (dt->min <= 59) && \ |
| VALID_SEC(dt->sec) && VALID_TZO(dt->tzo)) |
| |
| #define VALID_DATETIME(dt) \ |
| (VALID_DATE(dt) && VALID_TIME(dt)) |
| |
| #define SECS_PER_MIN (60) |
| #define SECS_PER_HOUR (60 * SECS_PER_MIN) |
| #define SECS_PER_DAY (24 * SECS_PER_HOUR) |
| |
| static const unsigned long dayInYearByMonth[12] = |
| { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }; |
| static const unsigned long dayInLeapYearByMonth[12] = |
| { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }; |
| |
| #define DAY_IN_YEAR(day, month, year) \ |
| ((IS_LEAP(year) ? \ |
| dayInLeapYearByMonth[month - 1] : \ |
| dayInYearByMonth[month - 1]) + day) |
| |
| /** |
| * _exsltDateParseGYear: |
| * @dt: pointer to a date structure |
| * @str: pointer to the string to analyze |
| * |
| * Parses a xs:gYear without time zone and fills in the appropriate |
| * field of the @dt structure. @str is updated to point just after the |
| * xs:gYear. It is supposed that @dt->year is big enough to contain |
| * the year. |
| * |
| * Returns 0 or the error code |
| */ |
| static int |
| _exsltDateParseGYear (exsltDateValDatePtr dt, const xmlChar **str) |
| { |
| const xmlChar *cur = *str, *firstChar; |
| int isneg = 0, digcnt = 0; |
| |
| if (((*cur < '0') || (*cur > '9')) && |
| (*cur != '-') && (*cur != '+')) |
| return -1; |
| |
| if (*cur == '-') { |
| isneg = 1; |
| cur++; |
| } |
| |
| firstChar = cur; |
| |
| while ((*cur >= '0') && (*cur <= '9')) { |
| dt->year = dt->year * 10 + (*cur - '0'); |
| cur++; |
| digcnt++; |
| } |
| |
| /* year must be at least 4 digits (CCYY); over 4 |
| * digits cannot have a leading zero. */ |
| if ((digcnt < 4) || ((digcnt > 4) && (*firstChar == '0'))) |
| return 1; |
| |
| if (isneg) |
| dt->year = - dt->year; |
| |
| if (!VALID_YEAR(dt->year)) |
| return 2; |
| |
| *str = cur; |
| |
| #ifdef DEBUG_EXSLT_DATE |
| xsltGenericDebug(xsltGenericDebugContext, |
| "Parsed year %04i\n", dt->year); |
| #endif |
| |
| return 0; |
| } |
| |
| /** |
| * FORMAT_GYEAR: |
| * @yr: the year to format |
| * @cur: a pointer to an allocated buffer |
| * |
| * Formats @yr in xsl:gYear format. Result is appended to @cur and |
| * @cur is updated to point after the xsl:gYear. |
| */ |
| #define FORMAT_GYEAR(yr, cur) \ |
| if (yr < 0) { \ |
| *cur = '-'; \ |
| cur++; \ |
| } \ |
| { \ |
| long year = (yr < 0) ? - yr : yr; \ |
| xmlChar tmp_buf[100], *tmp = tmp_buf; \ |
| /* result is in reverse-order */ \ |
| while (year > 0) { \ |
| *tmp = '0' + (xmlChar)(year % 10); \ |
| year /= 10; \ |
| tmp++; \ |
| } \ |
| /* virtually adds leading zeros */ \ |
| while ((tmp - tmp_buf) < 4) \ |
| *tmp++ = '0'; \ |
| /* restore the correct order */ \ |
| while (tmp > tmp_buf) { \ |
| tmp--; \ |
| *cur = *tmp; \ |
| cur++; \ |
| } \ |
| } |
| |
| /** |
| * PARSE_2_DIGITS: |
| * @num: the integer to fill in |
| * @cur: an #xmlChar * |
| * @func: validation function for the number |
| * @invalid: an integer |
| * |
| * Parses a 2-digits integer and updates @num with the value. @cur is |
| * updated to point just after the integer. |
| * In case of error, @invalid is set to %TRUE, values of @num and |
| * @cur are undefined. |
| */ |
| #define PARSE_2_DIGITS(num, cur, func, invalid) \ |
| if ((cur[0] < '0') || (cur[0] > '9') || \ |
| (cur[1] < '0') || (cur[1] > '9')) \ |
| invalid = 1; \ |
| else { \ |
| int val; \ |
| val = (cur[0] - '0') * 10 + (cur[1] - '0'); \ |
| if (!func(val)) \ |
| invalid = 2; \ |
| else \ |
| num = val; \ |
| } \ |
| cur += 2; |
| |
| /** |
| * FORMAT_2_DIGITS: |
| * @num: the integer to format |
| * @cur: a pointer to an allocated buffer |
| * |
| * Formats a 2-digits integer. Result is appended to @cur and |
| * @cur is updated to point after the integer. |
| */ |
| #define FORMAT_2_DIGITS(num, cur) \ |
| *cur = '0' + ((num / 10) % 10); \ |
| cur++; \ |
| *cur = '0' + (num % 10); \ |
| cur++; |
| |
| /** |
| * PARSE_FLOAT: |
| * @num: the double to fill in |
| * @cur: an #xmlChar * |
| * @invalid: an integer |
| * |
| * Parses a float and updates @num with the value. @cur is |
| * updated to point just after the float. The float must have a |
| * 2-digits integer part and may or may not have a decimal part. |
| * In case of error, @invalid is set to %TRUE, values of @num and |
| * @cur are undefined. |
| */ |
| #define PARSE_FLOAT(num, cur, invalid) \ |
| PARSE_2_DIGITS(num, cur, VALID_ALWAYS, invalid); \ |
| if (!invalid && (*cur == '.')) { \ |
| double mult = 1; \ |
| cur++; \ |
| if ((*cur < '0') || (*cur > '9')) \ |
| invalid = 1; \ |
| while ((*cur >= '0') && (*cur <= '9')) { \ |
| mult /= 10; \ |
| num += (*cur - '0') * mult; \ |
| cur++; \ |
| } \ |
| } |
| |
| /** |
| * FORMAT_FLOAT: |
| * @num: the double to format |
| * @cur: a pointer to an allocated buffer |
| * @pad: a flag for padding to 2 integer digits |
| * |
| * Formats a float. Result is appended to @cur and @cur is updated to |
| * point after the integer. If the @pad flag is non-zero, then the |
| * float representation has a minimum 2-digits integer part. The |
| * fractional part is formatted if @num has a fractional value. |
| */ |
| #define FORMAT_FLOAT(num, cur, pad) \ |
| { \ |
| xmlChar *sav, *str; \ |
| if ((pad) && (num < 10.0)) \ |
| *cur++ = '0'; \ |
| str = xmlXPathCastNumberToString(num); \ |
| sav = str; \ |
| while (*str != 0) \ |
| *cur++ = *str++; \ |
| xmlFree(sav); \ |
| } |
| |
| /** |
| * _exsltDateParseGMonth: |
| * @dt: pointer to a date structure |
| * @str: pointer to the string to analyze |
| * |
| * Parses a xs:gMonth without time zone and fills in the appropriate |
| * field of the @dt structure. @str is updated to point just after the |
| * xs:gMonth. |
| * |
| * Returns 0 or the error code |
| */ |
| static int |
| _exsltDateParseGMonth (exsltDateValDatePtr dt, const xmlChar **str) |
| { |
| const xmlChar *cur = *str; |
| int ret = 0; |
| |
| PARSE_2_DIGITS(dt->mon, cur, VALID_MONTH, ret); |
| if (ret != 0) |
| return ret; |
| |
| *str = cur; |
| |
| #ifdef DEBUG_EXSLT_DATE |
| xsltGenericDebug(xsltGenericDebugContext, |
| "Parsed month %02i\n", dt->mon); |
| #endif |
| |
| return 0; |
| } |
| |
| /** |
| * FORMAT_GMONTH: |
| * @mon: the month to format |
| * @cur: a pointer to an allocated buffer |
| * |
| * Formats @mon in xsl:gMonth format. Result is appended to @cur and |
| * @cur is updated to point after the xsl:gMonth. |
| */ |
| #define FORMAT_GMONTH(mon, cur) \ |
| FORMAT_2_DIGITS(mon, cur) |
| |
| /** |
| * _exsltDateParseGDay: |
| * @dt: pointer to a date structure |
| * @str: pointer to the string to analyze |
| * |
| * Parses a xs:gDay without time zone and fills in the appropriate |
| * field of the @dt structure. @str is updated to point just after the |
| * xs:gDay. |
| * |
| * Returns 0 or the error code |
| */ |
| static int |
| _exsltDateParseGDay (exsltDateValDatePtr dt, const xmlChar **str) |
| { |
| const xmlChar *cur = *str; |
| int ret = 0; |
| |
| PARSE_2_DIGITS(dt->day, cur, VALID_DAY, ret); |
| if (ret != 0) |
| return ret; |
| |
| *str = cur; |
| |
| #ifdef DEBUG_EXSLT_DATE |
| xsltGenericDebug(xsltGenericDebugContext, |
| "Parsed day %02i\n", dt->day); |
| #endif |
| |
| return 0; |
| } |
| |
| /** |
| * FORMAT_GDAY: |
| * @dt: the #exsltDateValDate to format |
| * @cur: a pointer to an allocated buffer |
| * |
| * Formats @dt in xsl:gDay format. Result is appended to @cur and |
| * @cur is updated to point after the xsl:gDay. |
| */ |
| #define FORMAT_GDAY(dt, cur) \ |
| FORMAT_2_DIGITS(dt->day, cur) |
| |
| /** |
| * FORMAT_DATE: |
| * @dt: the #exsltDateValDate to format |
| * @cur: a pointer to an allocated buffer |
| * |
| * Formats @dt in xsl:date format. Result is appended to @cur and |
| * @cur is updated to point after the xsl:date. |
| */ |
| #define FORMAT_DATE(dt, cur) \ |
| FORMAT_GYEAR(dt->year, cur); \ |
| *cur = '-'; \ |
| cur++; \ |
| FORMAT_GMONTH(dt->mon, cur); \ |
| *cur = '-'; \ |
| cur++; \ |
| FORMAT_GDAY(dt, cur); |
| |
| /** |
| * _exsltDateParseTime: |
| * @dt: pointer to a date structure |
| * @str: pointer to the string to analyze |
| * |
| * Parses a xs:time without time zone and fills in the appropriate |
| * fields of the @dt structure. @str is updated to point just after the |
| * xs:time. |
| * In case of error, values of @dt fields are undefined. |
| * |
| * Returns 0 or the error code |
| */ |
| static int |
| _exsltDateParseTime (exsltDateValDatePtr dt, const xmlChar **str) |
| { |
| const xmlChar *cur = *str; |
| unsigned int hour = 0; /* use temp var in case str is not xs:time */ |
| int ret = 0; |
| |
| PARSE_2_DIGITS(hour, cur, VALID_HOUR, ret); |
| if (ret != 0) |
| return ret; |
| |
| if (*cur != ':') |
| return 1; |
| cur++; |
| |
| /* the ':' insures this string is xs:time */ |
| dt->hour = hour; |
| |
| PARSE_2_DIGITS(dt->min, cur, VALID_MIN, ret); |
| if (ret != 0) |
| return ret; |
| |
| if (*cur != ':') |
| return 1; |
| cur++; |
| |
| PARSE_FLOAT(dt->sec, cur, ret); |
| if (ret != 0) |
| return ret; |
| |
| if (!VALID_TIME(dt)) |
| return 2; |
| |
| *str = cur; |
| |
| #ifdef DEBUG_EXSLT_DATE |
| xsltGenericDebug(xsltGenericDebugContext, |
| "Parsed time %02i:%02i:%02.f\n", |
| dt->hour, dt->min, dt->sec); |
| #endif |
| |
| return 0; |
| } |
| |
| /** |
| * FORMAT_TIME: |
| * @dt: the #exsltDateValDate to format |
| * @cur: a pointer to an allocated buffer |
| * |
| * Formats @dt in xsl:time format. Result is appended to @cur and |
| * @cur is updated to point after the xsl:time. |
| */ |
| #define FORMAT_TIME(dt, cur) \ |
| FORMAT_2_DIGITS(dt->hour, cur); \ |
| *cur = ':'; \ |
| cur++; \ |
| FORMAT_2_DIGITS(dt->min, cur); \ |
| *cur = ':'; \ |
| cur++; \ |
| FORMAT_FLOAT(dt->sec, cur, 1); |
| |
| /** |
| * _exsltDateParseTimeZone: |
| * @dt: pointer to a date structure |
| * @str: pointer to the string to analyze |
| * |
| * Parses a time zone without time zone and fills in the appropriate |
| * field of the @dt structure. @str is updated to point just after the |
| * time zone. |
| * |
| * Returns 0 or the error code |
| */ |
| static int |
| _exsltDateParseTimeZone (exsltDateValDatePtr dt, const xmlChar **str) |
| { |
| const xmlChar *cur; |
| int ret = 0; |
| |
| if (str == NULL) |
| return -1; |
| cur = *str; |
| switch (*cur) { |
| case 0: |
| dt->tz_flag = 0; |
| dt->tzo = 0; |
| break; |
| |
| case 'Z': |
| dt->tz_flag = 1; |
| dt->tzo = 0; |
| cur++; |
| break; |
| |
| case '+': |
| case '-': { |
| int isneg = 0, tmp = 0; |
| isneg = (*cur == '-'); |
| |
| cur++; |
| |
| PARSE_2_DIGITS(tmp, cur, VALID_HOUR, ret); |
| if (ret != 0) |
| return ret; |
| |
| if (*cur != ':') |
| return 1; |
| cur++; |
| |
| dt->tzo = tmp * 60; |
| |
| PARSE_2_DIGITS(tmp, cur, VALID_MIN, ret); |
| if (ret != 0) |
| return ret; |
| |
| dt->tzo += tmp; |
| if (isneg) |
| dt->tzo = - dt->tzo; |
| |
| if (!VALID_TZO(dt->tzo)) |
| return 2; |
| |
| break; |
| } |
| default: |
| return 1; |
| } |
| |
| *str = cur; |
| |
| #ifdef DEBUG_EXSLT_DATE |
| xsltGenericDebug(xsltGenericDebugContext, |
| "Parsed time zone offset (%s) %i\n", |
| dt->tz_flag ? "explicit" : "implicit", dt->tzo); |
| #endif |
| |
| return 0; |
| } |
| |
| /** |
| * FORMAT_TZ: |
| * @tzo: the timezone offset to format |
| * @cur: a pointer to an allocated buffer |
| * |
| * Formats @tzo timezone. Result is appended to @cur and |
| * @cur is updated to point after the timezone. |
| */ |
| #define FORMAT_TZ(tzo, cur) \ |
| if (tzo == 0) { \ |
| *cur = 'Z'; \ |
| cur++; \ |
| } else { \ |
| int aTzo = (tzo < 0) ? - tzo : tzo; \ |
| int tzHh = aTzo / 60, tzMm = aTzo % 60; \ |
| *cur = (tzo < 0) ? '-' : '+' ; \ |
| cur++; \ |
| FORMAT_2_DIGITS(tzHh, cur); \ |
| *cur = ':'; \ |
| cur++; \ |
| FORMAT_2_DIGITS(tzMm, cur); \ |
| } |
| |
| /**************************************************************** |
| * * |
| * XML Schema Dates/Times Datatypes Handling * |
| * * |
| ****************************************************************/ |
| |
| /** |
| * exsltDateCreateDate: |
| * @type: type to create |
| * |
| * Creates a new #exsltDateVal, uninitialized. |
| * |
| * Returns the #exsltDateValPtr |
| */ |
| static exsltDateValPtr |
| exsltDateCreateDate (exsltDateType type) |
| { |
| exsltDateValPtr ret; |
| |
| ret = (exsltDateValPtr) xmlMalloc(sizeof(exsltDateVal)); |
| if (ret == NULL) { |
| xsltGenericError(xsltGenericErrorContext, |
| "exsltDateCreateDate: out of memory\n"); |
| return (NULL); |
| } |
| memset (ret, 0, sizeof(exsltDateVal)); |
| |
| if (type != XS_DURATION) { |
| ret->value.date.mon = 1; |
| ret->value.date.day = 1; |
| } |
| |
| if (type != EXSLT_UNKNOWN) |
| ret->type = type; |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateFreeDate: |
| * @date: an #exsltDateValPtr |
| * |
| * Frees up the @date |
| */ |
| static void |
| exsltDateFreeDate (exsltDateValPtr date) { |
| if (date == NULL) |
| return; |
| |
| xmlFree(date); |
| } |
| |
| /** |
| * PARSE_DIGITS: |
| * @num: the integer to fill in |
| * @cur: an #xmlChar * |
| * @num_type: an integer flag |
| * |
| * Parses a digits integer and updates @num with the value. @cur is |
| * updated to point just after the integer. |
| * In case of error, @num_type is set to -1, values of @num and |
| * @cur are undefined. |
| */ |
| #define PARSE_DIGITS(num, cur, num_type) \ |
| if ((*cur < '0') || (*cur > '9')) \ |
| num_type = -1; \ |
| else \ |
| while ((*cur >= '0') && (*cur <= '9')) { \ |
| num = num * 10 + (*cur - '0'); \ |
| cur++; \ |
| } |
| |
| /** |
| * PARSE_NUM: |
| * @num: the double to fill in |
| * @cur: an #xmlChar * |
| * @num_type: an integer flag |
| * |
| * Parses a float or integer and updates @num with the value. @cur is |
| * updated to point just after the number. If the number is a float, |
| * then it must have an integer part and a decimal part; @num_type will |
| * be set to 1. If there is no decimal part, @num_type is set to zero. |
| * In case of error, @num_type is set to -1, values of @num and |
| * @cur are undefined. |
| */ |
| #define PARSE_NUM(num, cur, num_type) \ |
| num = 0; \ |
| PARSE_DIGITS(num, cur, num_type); \ |
| if (!num_type && (*cur == '.')) { \ |
| double mult = 1; \ |
| cur++; \ |
| if ((*cur < '0') || (*cur > '9')) \ |
| num_type = -1; \ |
| else \ |
| num_type = 1; \ |
| while ((*cur >= '0') && (*cur <= '9')) { \ |
| mult /= 10; \ |
| num += (*cur - '0') * mult; \ |
| cur++; \ |
| } \ |
| } |
| |
| #ifdef WITH_TIME |
| /** |
| * exsltDateCurrent: |
| * |
| * Returns the current date and time. |
| */ |
| static exsltDateValPtr |
| exsltDateCurrent (void) |
| { |
| struct tm localTm, gmTm; |
| time_t secs; |
| int local_s, gm_s; |
| exsltDateValPtr ret; |
| |
| ret = exsltDateCreateDate(XS_DATETIME); |
| if (ret == NULL) |
| return NULL; |
| |
| /* get current time */ |
| secs = time(NULL); |
| #if HAVE_LOCALTIME_R |
| localtime_r(&secs, &localTm); |
| #else |
| localTm = *localtime(&secs); |
| #endif |
| |
| /* get real year, not years since 1900 */ |
| ret->value.date.year = localTm.tm_year + 1900; |
| |
| ret->value.date.mon = localTm.tm_mon + 1; |
| ret->value.date.day = localTm.tm_mday; |
| ret->value.date.hour = localTm.tm_hour; |
| ret->value.date.min = localTm.tm_min; |
| |
| /* floating point seconds */ |
| ret->value.date.sec = (double) localTm.tm_sec; |
| |
| /* determine the time zone offset from local to gm time */ |
| #if HAVE_GMTIME_R |
| gmtime_r(&secs, &gmTm); |
| #else |
| gmTm = *gmtime(&secs); |
| #endif |
| ret->value.date.tz_flag = 0; |
| #if 0 |
| ret->value.date.tzo = (((ret->value.date.day * 1440) + |
| (ret->value.date.hour * 60) + |
| ret->value.date.min) - |
| ((gmTm.tm_mday * 1440) + (gmTm.tm_hour * 60) + |
| gmTm.tm_min)); |
| #endif |
| local_s = localTm.tm_hour * SECS_PER_HOUR + |
| localTm.tm_min * SECS_PER_MIN + |
| localTm.tm_sec; |
| |
| gm_s = gmTm.tm_hour * SECS_PER_HOUR + |
| gmTm.tm_min * SECS_PER_MIN + |
| gmTm.tm_sec; |
| |
| if (localTm.tm_year < gmTm.tm_year) { |
| ret->value.date.tzo = -((SECS_PER_DAY - local_s) + gm_s)/60; |
| } else if (localTm.tm_year > gmTm.tm_year) { |
| ret->value.date.tzo = ((SECS_PER_DAY - gm_s) + local_s)/60; |
| } else if (localTm.tm_mon < gmTm.tm_mon) { |
| ret->value.date.tzo = -((SECS_PER_DAY - local_s) + gm_s)/60; |
| } else if (localTm.tm_mon > gmTm.tm_mon) { |
| ret->value.date.tzo = ((SECS_PER_DAY - gm_s) + local_s)/60; |
| } else if (localTm.tm_mday < gmTm.tm_mday) { |
| ret->value.date.tzo = -((SECS_PER_DAY - local_s) + gm_s)/60; |
| } else if (localTm.tm_mday > gmTm.tm_mday) { |
| ret->value.date.tzo = ((SECS_PER_DAY - gm_s) + local_s)/60; |
| } else { |
| ret->value.date.tzo = (local_s - gm_s)/60; |
| } |
| |
| return ret; |
| } |
| #endif |
| |
| /** |
| * exsltDateParse: |
| * @dateTime: string to analyze |
| * |
| * Parses a date/time string |
| * |
| * Returns a newly built #exsltDateValPtr of NULL in case of error |
| */ |
| static exsltDateValPtr |
| exsltDateParse (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| int ret; |
| const xmlChar *cur = dateTime; |
| |
| #define RETURN_TYPE_IF_VALID(t) \ |
| if (IS_TZO_CHAR(*cur)) { \ |
| ret = _exsltDateParseTimeZone(&(dt->value.date), &cur); \ |
| if (ret == 0) { \ |
| if (*cur != 0) \ |
| goto error; \ |
| dt->type = t; \ |
| return dt; \ |
| } \ |
| } |
| |
| if (dateTime == NULL) |
| return NULL; |
| |
| if ((*cur != '-') && (*cur < '0') && (*cur > '9')) |
| return NULL; |
| |
| dt = exsltDateCreateDate(EXSLT_UNKNOWN); |
| if (dt == NULL) |
| return NULL; |
| |
| if ((cur[0] == '-') && (cur[1] == '-')) { |
| /* |
| * It's an incomplete date (xs:gMonthDay, xs:gMonth or |
| * xs:gDay) |
| */ |
| cur += 2; |
| |
| /* is it an xs:gDay? */ |
| if (*cur == '-') { |
| ++cur; |
| ret = _exsltDateParseGDay(&(dt->value.date), &cur); |
| if (ret != 0) |
| goto error; |
| |
| RETURN_TYPE_IF_VALID(XS_GDAY); |
| |
| goto error; |
| } |
| |
| /* |
| * it should be an xs:gMonthDay or xs:gMonth |
| */ |
| ret = _exsltDateParseGMonth(&(dt->value.date), &cur); |
| if (ret != 0) |
| goto error; |
| |
| if (*cur != '-') |
| goto error; |
| cur++; |
| |
| /* is it an xs:gMonth? */ |
| if (*cur == '-') { |
| cur++; |
| RETURN_TYPE_IF_VALID(XS_GMONTH); |
| goto error; |
| } |
| |
| /* it should be an xs:gMonthDay */ |
| ret = _exsltDateParseGDay(&(dt->value.date), &cur); |
| if (ret != 0) |
| goto error; |
| |
| RETURN_TYPE_IF_VALID(XS_GMONTHDAY); |
| |
| goto error; |
| } |
| |
| /* |
| * It's a right-truncated date or an xs:time. |
| * Try to parse an xs:time then fallback on right-truncated dates. |
| */ |
| if ((*cur >= '0') && (*cur <= '9')) { |
| ret = _exsltDateParseTime(&(dt->value.date), &cur); |
| if (ret == 0) { |
| /* it's an xs:time */ |
| RETURN_TYPE_IF_VALID(XS_TIME); |
| } |
| } |
| |
| /* fallback on date parsing */ |
| cur = dateTime; |
| |
| ret = _exsltDateParseGYear(&(dt->value.date), &cur); |
| if (ret != 0) |
| goto error; |
| |
| /* is it an xs:gYear? */ |
| RETURN_TYPE_IF_VALID(XS_GYEAR); |
| |
| if (*cur != '-') |
| goto error; |
| cur++; |
| |
| ret = _exsltDateParseGMonth(&(dt->value.date), &cur); |
| if (ret != 0) |
| goto error; |
| |
| /* is it an xs:gYearMonth? */ |
| RETURN_TYPE_IF_VALID(XS_GYEARMONTH); |
| |
| if (*cur != '-') |
| goto error; |
| cur++; |
| |
| ret = _exsltDateParseGDay(&(dt->value.date), &cur); |
| if ((ret != 0) || !VALID_DATE((&(dt->value.date)))) |
| goto error; |
| |
| /* is it an xs:date? */ |
| RETURN_TYPE_IF_VALID(XS_DATE); |
| |
| if (*cur != 'T') |
| goto error; |
| cur++; |
| |
| /* it should be an xs:dateTime */ |
| ret = _exsltDateParseTime(&(dt->value.date), &cur); |
| if (ret != 0) |
| goto error; |
| |
| ret = _exsltDateParseTimeZone(&(dt->value.date), &cur); |
| if ((ret != 0) || (*cur != 0) || !VALID_DATETIME((&(dt->value.date)))) |
| goto error; |
| |
| dt->type = XS_DATETIME; |
| |
| return dt; |
| |
| error: |
| if (dt != NULL) |
| exsltDateFreeDate(dt); |
| return NULL; |
| } |
| |
| /** |
| * exsltDateParseDuration: |
| * @duration: string to analyze |
| * |
| * Parses a duration string |
| * |
| * Returns a newly built #exsltDateValPtr of NULL in case of error |
| */ |
| static exsltDateValPtr |
| exsltDateParseDuration (const xmlChar *duration) |
| { |
| const xmlChar *cur = duration; |
| exsltDateValPtr dur; |
| int isneg = 0; |
| unsigned int seq = 0; |
| |
| if (duration == NULL) |
| return NULL; |
| |
| if (*cur == '-') { |
| isneg = 1; |
| cur++; |
| } |
| |
| /* duration must start with 'P' (after sign) */ |
| if (*cur++ != 'P') |
| return NULL; |
| |
| dur = exsltDateCreateDate(XS_DURATION); |
| if (dur == NULL) |
| return NULL; |
| |
| while (*cur != 0) { |
| double num; |
| int num_type = 0; /* -1 = invalid, 0 = int, 1 = floating */ |
| const xmlChar desig[] = {'Y', 'M', 'D', 'H', 'M', 'S'}; |
| const double multi[] = { 0.0, 0.0, 86400.0, 3600.0, 60.0, 1.0, 0.0}; |
| |
| /* input string should be empty or invalid date/time item */ |
| if (seq >= sizeof(desig)) |
| goto error; |
| |
| /* T designator must be present for time items */ |
| if (*cur == 'T') { |
| if (seq <= 3) { |
| seq = 3; |
| cur++; |
| } else |
| return NULL; |
| } else if (seq == 3) |
| goto error; |
| |
| /* parse the number portion of the item */ |
| PARSE_NUM(num, cur, num_type); |
| |
| if ((num_type == -1) || (*cur == 0)) |
| goto error; |
| |
| /* update duration based on item type */ |
| while (seq < sizeof(desig)) { |
| if (*cur == desig[seq]) { |
| |
| /* verify numeric type; only seconds can be float */ |
| if ((num_type != 0) && (seq < (sizeof(desig)-1))) |
| goto error; |
| |
| switch (seq) { |
| case 0: |
| dur->value.dur.mon = (long)num * 12; |
| break; |
| case 1: |
| dur->value.dur.mon += (long)num; |
| break; |
| default: |
| /* convert to seconds using multiplier */ |
| dur->value.dur.sec += num * multi[seq]; |
| seq++; |
| break; |
| } |
| |
| break; /* exit loop */ |
| } |
| /* no date designators found? */ |
| if (++seq == 3) |
| goto error; |
| } |
| cur++; |
| } |
| |
| if (isneg) { |
| dur->value.dur.mon = -dur->value.dur.mon; |
| dur->value.dur.day = -dur->value.dur.day; |
| dur->value.dur.sec = -dur->value.dur.sec; |
| } |
| |
| #ifdef DEBUG_EXSLT_DATE |
| xsltGenericDebug(xsltGenericDebugContext, |
| "Parsed duration %f\n", dur->value.dur.sec); |
| #endif |
| |
| return dur; |
| |
| error: |
| if (dur != NULL) |
| exsltDateFreeDate(dur); |
| return NULL; |
| } |
| |
| /** |
| * FORMAT_ITEM: |
| * @num: number to format |
| * @cur: current location to convert number |
| * @limit: max value |
| * @item: char designator |
| * |
| */ |
| #define FORMAT_ITEM(num, cur, limit, item) \ |
| if (num != 0) { \ |
| long comp = (long)num / limit; \ |
| if (comp != 0) { \ |
| FORMAT_FLOAT((double)comp, cur, 0); \ |
| *cur++ = item; \ |
| num -= (double)(comp * limit); \ |
| } \ |
| } |
| |
| /** |
| * exsltDateFormatDuration: |
| * @dt: an #exsltDateValDurationPtr |
| * |
| * Formats @dt in xs:duration format. |
| * |
| * Returns a newly allocated string, or NULL in case of error |
| */ |
| static xmlChar * |
| exsltDateFormatDuration (const exsltDateValDurationPtr dt) |
| { |
| xmlChar buf[100], *cur = buf; |
| double secs, days; |
| double years, months; |
| |
| if (dt == NULL) |
| return NULL; |
| |
| /* quick and dirty check */ |
| if ((dt->sec == 0.0) && (dt->day == 0) && (dt->mon == 0)) |
| return xmlStrdup((xmlChar*)"P0D"); |
| |
| secs = dt->sec; |
| days = (double)dt->day; |
| years = (double)(dt->mon / 12); |
| months = (double)(dt->mon % 12); |
| |
| *cur = '\0'; |
| if (secs < 0.0) { |
| secs = -secs; |
| *cur = '-'; |
| } |
| if (days < 0) { |
| days = -days; |
| *cur = '-'; |
| } |
| if (years < 0) { |
| years = -years; |
| *cur = '-'; |
| } |
| if (months < 0) { |
| months = -months; |
| *cur = '-'; |
| } |
| if (*cur == '-') |
| cur++; |
| |
| *cur++ = 'P'; |
| |
| if (years != 0.0) { |
| FORMAT_ITEM(years, cur, 1, 'Y'); |
| } |
| |
| if (months != 0.0) { |
| FORMAT_ITEM(months, cur, 1, 'M'); |
| } |
| |
| if (secs >= SECS_PER_DAY) { |
| double tmp = floor(secs / SECS_PER_DAY); |
| days += tmp; |
| secs -= (tmp * SECS_PER_DAY); |
| } |
| |
| FORMAT_ITEM(days, cur, 1, 'D'); |
| if (secs > 0.0) { |
| *cur++ = 'T'; |
| } |
| FORMAT_ITEM(secs, cur, SECS_PER_HOUR, 'H'); |
| FORMAT_ITEM(secs, cur, SECS_PER_MIN, 'M'); |
| if (secs > 0.0) { |
| FORMAT_FLOAT(secs, cur, 0); |
| *cur++ = 'S'; |
| } |
| |
| *cur = 0; |
| |
| return xmlStrdup(buf); |
| } |
| |
| /** |
| * exsltDateFormatDateTime: |
| * @dt: an #exsltDateValDatePtr |
| * |
| * Formats @dt in xs:dateTime format. |
| * |
| * Returns a newly allocated string, or NULL in case of error |
| */ |
| static xmlChar * |
| exsltDateFormatDateTime (const exsltDateValDatePtr dt) |
| { |
| xmlChar buf[100], *cur = buf; |
| |
| if ((dt == NULL) || !VALID_DATETIME(dt)) |
| return NULL; |
| |
| FORMAT_DATE(dt, cur); |
| *cur = 'T'; |
| cur++; |
| FORMAT_TIME(dt, cur); |
| FORMAT_TZ(dt->tzo, cur); |
| *cur = 0; |
| |
| return xmlStrdup(buf); |
| } |
| |
| /** |
| * exsltDateFormatDate: |
| * @dt: an #exsltDateValDatePtr |
| * |
| * Formats @dt in xs:date format. |
| * |
| * Returns a newly allocated string, or NULL in case of error |
| */ |
| static xmlChar * |
| exsltDateFormatDate (const exsltDateValDatePtr dt) |
| { |
| xmlChar buf[100], *cur = buf; |
| |
| if ((dt == NULL) || !VALID_DATETIME(dt)) |
| return NULL; |
| |
| FORMAT_DATE(dt, cur); |
| if (dt->tz_flag || (dt->tzo != 0)) { |
| FORMAT_TZ(dt->tzo, cur); |
| } |
| *cur = 0; |
| |
| return xmlStrdup(buf); |
| } |
| |
| /** |
| * exsltDateFormatTime: |
| * @dt: an #exsltDateValDatePtr |
| * |
| * Formats @dt in xs:time format. |
| * |
| * Returns a newly allocated string, or NULL in case of error |
| */ |
| static xmlChar * |
| exsltDateFormatTime (const exsltDateValDatePtr dt) |
| { |
| xmlChar buf[100], *cur = buf; |
| |
| if ((dt == NULL) || !VALID_TIME(dt)) |
| return NULL; |
| |
| FORMAT_TIME(dt, cur); |
| if (dt->tz_flag || (dt->tzo != 0)) { |
| FORMAT_TZ(dt->tzo, cur); |
| } |
| *cur = 0; |
| |
| return xmlStrdup(buf); |
| } |
| |
| /** |
| * exsltDateFormat: |
| * @dt: an #exsltDateValPtr |
| * |
| * Formats @dt in the proper format. |
| * Note: xs:gmonth and xs:gday are not formatted as there are no |
| * routines that output them. |
| * |
| * Returns a newly allocated string, or NULL in case of error |
| */ |
| static xmlChar * |
| exsltDateFormat (const exsltDateValPtr dt) |
| { |
| |
| if (dt == NULL) |
| return NULL; |
| |
| switch (dt->type) { |
| case XS_DURATION: |
| return exsltDateFormatDuration(&(dt->value.dur)); |
| case XS_DATETIME: |
| return exsltDateFormatDateTime(&(dt->value.date)); |
| case XS_DATE: |
| return exsltDateFormatDate(&(dt->value.date)); |
| case XS_TIME: |
| return exsltDateFormatTime(&(dt->value.date)); |
| default: |
| break; |
| } |
| |
| if (dt->type & XS_GYEAR) { |
| xmlChar buf[20], *cur = buf; |
| |
| FORMAT_GYEAR(dt->value.date.year, cur); |
| if (dt->type == XS_GYEARMONTH) { |
| *cur = '-'; |
| cur++; |
| FORMAT_GMONTH(dt->value.date.mon, cur); |
| } |
| |
| if (dt->value.date.tz_flag || (dt->value.date.tzo != 0)) { |
| FORMAT_TZ(dt->value.date.tzo, cur); |
| } |
| *cur = 0; |
| return xmlStrdup(buf); |
| } |
| |
| return NULL; |
| } |
| |
| /** |
| * _exsltDateCastYMToDays: |
| * @dt: an #exsltDateValPtr |
| * |
| * Convert mon and year of @dt to total number of days. Take the |
| * number of years since (or before) 1 AD and add the number of leap |
| * years. This is a function because negative |
| * years must be handled a little differently and there is no zero year. |
| * |
| * Returns number of days. |
| */ |
| static long |
| _exsltDateCastYMToDays (const exsltDateValPtr dt) |
| { |
| long ret; |
| |
| if (dt->value.date.year < 0) |
| ret = (dt->value.date.year * 365) + |
| (((dt->value.date.year+1)/4)-((dt->value.date.year+1)/100)+ |
| ((dt->value.date.year+1)/400)) + |
| DAY_IN_YEAR(0, dt->value.date.mon, dt->value.date.year); |
| else |
| ret = ((dt->value.date.year-1) * 365) + |
| (((dt->value.date.year-1)/4)-((dt->value.date.year-1)/100)+ |
| ((dt->value.date.year-1)/400)) + |
| DAY_IN_YEAR(0, dt->value.date.mon, dt->value.date.year); |
| |
| return ret; |
| } |
| |
| /** |
| * TIME_TO_NUMBER: |
| * @dt: an #exsltDateValPtr |
| * |
| * Calculates the number of seconds in the time portion of @dt. |
| * |
| * Returns seconds. |
| */ |
| #define TIME_TO_NUMBER(dt) \ |
| ((double)((dt->value.date.hour * SECS_PER_HOUR) + \ |
| (dt->value.date.min * SECS_PER_MIN)) + dt->value.date.sec) |
| |
| /** |
| * exsltDateCastDateToNumber: |
| * @dt: an #exsltDateValPtr |
| * |
| * Calculates the number of seconds from year zero. |
| * |
| * Returns seconds from zero year. |
| */ |
| static double |
| exsltDateCastDateToNumber (const exsltDateValPtr dt) |
| { |
| double ret = 0.0; |
| |
| if (dt == NULL) |
| return 0.0; |
| |
| if ((dt->type & XS_GYEAR) == XS_GYEAR) { |
| ret = (double)_exsltDateCastYMToDays(dt) * SECS_PER_DAY; |
| } |
| |
| /* add in days */ |
| if (dt->type == XS_DURATION) { |
| ret += (double)dt->value.dur.day * SECS_PER_DAY; |
| ret += dt->value.dur.sec; |
| } else { |
| ret += (double)dt->value.date.day * SECS_PER_DAY; |
| /* add in time */ |
| ret += TIME_TO_NUMBER(dt); |
| } |
| |
| |
| return ret; |
| } |
| |
| /** |
| * _exsltDateTruncateDate: |
| * @dt: an #exsltDateValPtr |
| * @type: dateTime type to set to |
| * |
| * Set @dt to truncated @type. |
| * |
| * Returns 0 success, non-zero otherwise. |
| */ |
| static int |
| _exsltDateTruncateDate (exsltDateValPtr dt, exsltDateType type) |
| { |
| if (dt == NULL) |
| return 1; |
| |
| if ((type & XS_TIME) != XS_TIME) { |
| dt->value.date.hour = 0; |
| dt->value.date.min = 0; |
| dt->value.date.sec = 0.0; |
| } |
| |
| if ((type & XS_GDAY) != XS_GDAY) |
| dt->value.date.day = 1; |
| |
| if ((type & XS_GMONTH) != XS_GMONTH) |
| dt->value.date.mon = 1; |
| |
| if ((type & XS_GYEAR) != XS_GYEAR) |
| dt->value.date.year = 0; |
| |
| dt->type = type; |
| |
| return 0; |
| } |
| |
| /** |
| * _exsltDayInWeek: |
| * @yday: year day (1-366) |
| * @yr: year |
| * |
| * Determine the day-in-week from @yday and @yr. 0001-01-01 was |
| * a Monday so all other days are calculated from there. Take the |
| * number of years since (or before) add the number of leap years and |
| * the day-in-year and mod by 7. This is a function because negative |
| * years must be handled a little differently and there is no zero year. |
| * |
| * Returns day in week (Sunday = 0). |
| */ |
| static long |
| _exsltDateDayInWeek(long yday, long yr) |
| { |
| long ret; |
| |
| if (yr < 0) { |
| ret = ((yr + (((yr+1)/4)-((yr+1)/100)+((yr+1)/400)) + yday) % 7); |
| if (ret < 0) |
| ret += 7; |
| } else |
| ret = (((yr-1) + (((yr-1)/4)-((yr-1)/100)+((yr-1)/400)) + yday) % 7); |
| |
| return ret; |
| } |
| |
| /* |
| * macros for adding date/times and durations |
| */ |
| #define FQUOTIENT(a,b) ((floor(((double)a/(double)b)))) |
| #define MODULO(a,b) ((a - FQUOTIENT(a,b) * b)) |
| #define FQUOTIENT_RANGE(a,low,high) (FQUOTIENT((a-low),(high-low))) |
| #define MODULO_RANGE(a,low,high) ((MODULO((a-low),(high-low)))+low) |
| |
| /** |
| * _exsltDateAdd: |
| * @dt: an #exsltDateValPtr |
| * @dur: an #exsltDateValPtr of type #XS_DURATION |
| * |
| * Compute a new date/time from @dt and @dur. This function assumes @dt |
| * is either #XS_DATETIME, #XS_DATE, #XS_GYEARMONTH, or #XS_GYEAR. |
| * |
| * Returns date/time pointer or NULL. |
| */ |
| static exsltDateValPtr |
| _exsltDateAdd (exsltDateValPtr dt, exsltDateValPtr dur) |
| { |
| exsltDateValPtr ret; |
| long carry, tempdays, temp; |
| exsltDateValDatePtr r, d; |
| exsltDateValDurationPtr u; |
| |
| if ((dt == NULL) || (dur == NULL)) |
| return NULL; |
| |
| ret = exsltDateCreateDate(dt->type); |
| if (ret == NULL) |
| return NULL; |
| |
| r = &(ret->value.date); |
| d = &(dt->value.date); |
| u = &(dur->value.dur); |
| |
| /* normalize for time zone offset */ |
| u->sec -= (d->tzo * 60); /* changed from + to - (bug 153000) */ |
| d->tzo = 0; |
| |
| /* month */ |
| carry = d->mon + u->mon; |
| r->mon = (unsigned int)MODULO_RANGE(carry, 1, 13); |
| carry = (long)FQUOTIENT_RANGE(carry, 1, 13); |
| |
| /* year (may be modified later) */ |
| r->year = d->year + carry; |
| if (r->year == 0) { |
| if (d->year > 0) |
| r->year--; |
| else |
| r->year++; |
| } |
| |
| /* time zone */ |
| r->tzo = d->tzo; |
| r->tz_flag = d->tz_flag; |
| |
| /* seconds */ |
| r->sec = d->sec + u->sec; |
| carry = (long)FQUOTIENT((long)r->sec, 60); |
| if (r->sec != 0.0) { |
| r->sec = MODULO(r->sec, 60.0); |
| } |
| |
| /* minute */ |
| carry += d->min; |
| r->min = (unsigned int)MODULO(carry, 60); |
| carry = (long)FQUOTIENT(carry, 60); |
| |
| /* hours */ |
| carry += d->hour; |
| r->hour = (unsigned int)MODULO(carry, 24); |
| carry = (long)FQUOTIENT(carry, 24); |
| |
| /* |
| * days |
| * Note we use tempdays because the temporary values may need more |
| * than 5 bits |
| */ |
| if ((VALID_YEAR(r->year)) && (VALID_MONTH(r->mon)) && |
| (d->day > MAX_DAYINMONTH(r->year, r->mon))) |
| tempdays = MAX_DAYINMONTH(r->year, r->mon); |
| else if (d->day < 1) |
| tempdays = 1; |
| else |
| tempdays = d->day; |
| |
| tempdays += u->day + carry; |
| |
| while (1) { |
| if (tempdays < 1) { |
| long tmon = (long)MODULO_RANGE((int)r->mon-1, 1, 13); |
| long tyr = r->year + (long)FQUOTIENT_RANGE((int)r->mon-1, 1, 13); |
| if (tyr == 0) |
| tyr--; |
| /* |
| * Coverity detected an overrun in daysInMonth |
| * of size 12 at position 12 with index variable "((r)->mon - 1)" |
| */ |
| if (tmon < 0) |
| tmon = 0; |
| if (tmon > 12) |
| tmon = 12; |
| tempdays += MAX_DAYINMONTH(tyr, tmon); |
| carry = -1; |
| } else if (tempdays > (long)MAX_DAYINMONTH(r->year, r->mon)) { |
| tempdays = tempdays - MAX_DAYINMONTH(r->year, r->mon); |
| carry = 1; |
| } else |
| break; |
| |
| temp = r->mon + carry; |
| r->mon = (unsigned int)MODULO_RANGE(temp, 1, 13); |
| r->year = r->year + (long)FQUOTIENT_RANGE(temp, 1, 13); |
| if (r->year == 0) { |
| if (temp < 1) |
| r->year--; |
| else |
| r->year++; |
| } |
| } |
| |
| r->day = tempdays; |
| |
| /* |
| * adjust the date/time type to the date values |
| */ |
| if (ret->type != XS_DATETIME) { |
| if ((r->hour) || (r->min) || (r->sec)) |
| ret->type = XS_DATETIME; |
| else if (ret->type != XS_DATE) { |
| if (r->day != 1) |
| ret->type = XS_DATE; |
| else if ((ret->type != XS_GYEARMONTH) && (r->mon != 1)) |
| ret->type = XS_GYEARMONTH; |
| } |
| } |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateNormalize: |
| * @dt: an #exsltDateValPtr |
| * |
| * Normalize @dt to GMT time. |
| * |
| */ |
| static void |
| exsltDateNormalize (exsltDateValPtr dt) |
| { |
| exsltDateValPtr dur, tmp; |
| |
| if (dt == NULL) |
| return; |
| |
| if (((dt->type & XS_TIME) != XS_TIME) && (dt->value.date.tzo == 0)) |
| return; |
| |
| dur = exsltDateCreateDate(XS_DURATION); |
| if (dur == NULL) |
| return; |
| |
| tmp = _exsltDateAdd(dt, dur); |
| if (tmp == NULL) |
| return; |
| |
| memcpy(dt, tmp, sizeof(exsltDateVal)); |
| |
| exsltDateFreeDate(tmp); |
| exsltDateFreeDate(dur); |
| |
| dt->value.date.tzo = 0; |
| } |
| |
| /** |
| * _exsltDateDifference: |
| * @x: an #exsltDateValPtr |
| * @y: an #exsltDateValPtr |
| * @flag: force difference in days |
| * |
| * Calculate the difference between @x and @y as a duration |
| * (i.e. y - x). If the @flag is set then even if the least specific |
| * format of @x or @y is xs:gYear or xs:gYearMonth. |
| * |
| * Returns date/time pointer or NULL. |
| */ |
| static exsltDateValPtr |
| _exsltDateDifference (exsltDateValPtr x, exsltDateValPtr y, int flag) |
| { |
| exsltDateValPtr ret; |
| |
| if ((x == NULL) || (y == NULL)) |
| return NULL; |
| |
| if (((x->type < XS_GYEAR) || (x->type > XS_DATETIME)) || |
| ((y->type < XS_GYEAR) || (y->type > XS_DATETIME))) |
| return NULL; |
| |
| exsltDateNormalize(x); |
| exsltDateNormalize(y); |
| |
| /* |
| * the operand with the most specific format must be converted to |
| * the same type as the operand with the least specific format. |
| */ |
| if (x->type != y->type) { |
| if (x->type < y->type) { |
| _exsltDateTruncateDate(y, x->type); |
| } else { |
| _exsltDateTruncateDate(x, y->type); |
| } |
| } |
| |
| ret = exsltDateCreateDate(XS_DURATION); |
| if (ret == NULL) |
| return NULL; |
| |
| if (((x->type == XS_GYEAR) || (x->type == XS_GYEARMONTH)) && (!flag)) { |
| /* compute the difference in months */ |
| ret->value.dur.mon = ((y->value.date.year * 12) + y->value.date.mon) - |
| ((x->value.date.year * 12) + x->value.date.mon); |
| /* The above will give a wrong result if x and y are on different sides |
| of the September 1752. Resolution is welcome :-) */ |
| } else { |
| ret->value.dur.day = _exsltDateCastYMToDays(y) - |
| _exsltDateCastYMToDays(x); |
| ret->value.dur.day += y->value.date.day - x->value.date.day; |
| ret->value.dur.sec = TIME_TO_NUMBER(y) - TIME_TO_NUMBER(x); |
| if (ret->value.dur.day > 0.0 && ret->value.dur.sec < 0.0) { |
| ret->value.dur.day -= 1; |
| ret->value.dur.sec = ret->value.dur.sec + SECS_PER_DAY; |
| } else if (ret->value.dur.day < 0.0 && ret->value.dur.sec > 0.0) { |
| ret->value.dur.day += 1; |
| ret->value.dur.sec = ret->value.dur.sec - SECS_PER_DAY; |
| } |
| } |
| |
| return ret; |
| } |
| |
| /** |
| * _exsltDateAddDurCalc |
| * @ret: an exsltDateValPtr for the return value: |
| * @x: an exsltDateValPtr for the first operand |
| * @y: an exsltDateValPtr for the second operand |
| * |
| * Add two durations, catering for possible negative values. |
| * The sum is placed in @ret. |
| * |
| * Returns 1 for success, 0 if error detected. |
| */ |
| static int |
| _exsltDateAddDurCalc (exsltDateValPtr ret, exsltDateValPtr x, |
| exsltDateValPtr y) |
| { |
| long carry; |
| |
| /* months */ |
| ret->value.dur.mon = x->value.dur.mon + y->value.dur.mon; |
| |
| /* seconds */ |
| ret->value.dur.sec = x->value.dur.sec + y->value.dur.sec; |
| carry = (long)FQUOTIENT(ret->value.dur.sec, SECS_PER_DAY); |
| if (ret->value.dur.sec != 0.0) { |
| ret->value.dur.sec = MODULO(ret->value.dur.sec, SECS_PER_DAY); |
| /* |
| * Our function MODULO always gives us a positive value, so |
| * if we end up with a "-ve" carry we need to adjust it |
| * appropriately (bug 154021) |
| */ |
| if ((carry < 0) && (ret->value.dur.sec != 0)) { |
| /* change seconds to equiv negative modulus */ |
| ret->value.dur.sec = ret->value.dur.sec - SECS_PER_DAY; |
| carry++; |
| } |
| } |
| |
| /* days */ |
| ret->value.dur.day = x->value.dur.day + y->value.dur.day + carry; |
| |
| /* |
| * are the results indeterminate? i.e. how do you subtract days from |
| * months or years? |
| */ |
| if ((((ret->value.dur.day > 0) || (ret->value.dur.sec > 0)) && |
| (ret->value.dur.mon < 0)) || |
| (((ret->value.dur.day < 0) || (ret->value.dur.sec < 0)) && |
| (ret->value.dur.mon > 0))) { |
| return 0; |
| } |
| return 1; |
| } |
| |
| /** |
| * _exsltDateAddDuration: |
| * @x: an #exsltDateValPtr of type #XS_DURATION |
| * @y: an #exsltDateValPtr of type #XS_DURATION |
| * |
| * Compute a new duration from @x and @y. |
| * |
| * Returns date/time pointer or NULL. |
| */ |
| static exsltDateValPtr |
| _exsltDateAddDuration (exsltDateValPtr x, exsltDateValPtr y) |
| { |
| exsltDateValPtr ret; |
| |
| if ((x == NULL) || (y == NULL)) |
| return NULL; |
| |
| ret = exsltDateCreateDate(XS_DURATION); |
| if (ret == NULL) |
| return NULL; |
| |
| if (_exsltDateAddDurCalc(ret, x, y)) |
| return ret; |
| |
| exsltDateFreeDate(ret); |
| return NULL; |
| } |
| |
| /**************************************************************** |
| * * |
| * EXSLT - Dates and Times functions * |
| * * |
| ****************************************************************/ |
| |
| /** |
| * exsltDateDateTime: |
| * |
| * Implements the EXSLT - Dates and Times date-time() function: |
| * string date:date-time() |
| * |
| * Returns the current date and time as a date/time string. |
| */ |
| static xmlChar * |
| exsltDateDateTime (void) |
| { |
| xmlChar *ret = NULL; |
| #ifdef WITH_TIME |
| exsltDateValPtr cur; |
| |
| cur = exsltDateCurrent(); |
| if (cur != NULL) { |
| ret = exsltDateFormatDateTime(&(cur->value.date)); |
| exsltDateFreeDate(cur); |
| } |
| #endif |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateDate: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times date() function: |
| * string date:date (string?) |
| * |
| * Returns the date specified in the date/time string given as the |
| * argument. If no argument is given, then the current local |
| * date/time, as returned by date:date-time is used as a default |
| * argument. |
| * The date/time string specified as an argument must be a string in |
| * the format defined as the lexical representation of either |
| * xs:dateTime or xs:date. If the argument is not in either of these |
| * formats, returns NULL. |
| */ |
| static xmlChar * |
| exsltDateDate (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt = NULL; |
| xmlChar *ret = NULL; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return NULL; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return NULL; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) { |
| exsltDateFreeDate(dt); |
| return NULL; |
| } |
| } |
| |
| ret = exsltDateFormatDate(&(dt->value.date)); |
| exsltDateFreeDate(dt); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateTime: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times time() function: |
| * string date:time (string?) |
| * |
| * Returns the time specified in the date/time string given as the |
| * argument. If no argument is given, then the current local |
| * date/time, as returned by date:date-time is used as a default |
| * argument. |
| * The date/time string specified as an argument must be a string in |
| * the format defined as the lexical representation of either |
| * xs:dateTime or xs:time. If the argument is not in either of these |
| * formats, returns NULL. |
| */ |
| static xmlChar * |
| exsltDateTime (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt = NULL; |
| xmlChar *ret = NULL; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return NULL; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return NULL; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_TIME)) { |
| exsltDateFreeDate(dt); |
| return NULL; |
| } |
| } |
| |
| ret = exsltDateFormatTime(&(dt->value.date)); |
| exsltDateFreeDate(dt); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateYear: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times year() function |
| * number date:year (string?) |
| * Returns the year of a date as a number. If no argument is given, |
| * then the current local date/time, as returned by date:date-time is |
| * used as a default argument. |
| * The date/time string specified as the first argument must be a |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * - xs:gYearMonth (CCYY-MM) |
| * - xs:gYear (CCYY) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| */ |
| static double |
| exsltDateYear (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| double ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE) && |
| (dt->type != XS_GYEARMONTH) && (dt->type != XS_GYEAR)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| ret = (double) dt->value.date.year; |
| exsltDateFreeDate(dt); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateLeapYear: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times leap-year() function: |
| * boolean date:leap-yea (string?) |
| * Returns true if the year given in a date is a leap year. If no |
| * argument is given, then the current local date/time, as returned by |
| * date:date-time is used as a default argument. |
| * The date/time string specified as the first argument must be a |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * - xs:gYearMonth (CCYY-MM) |
| * - xs:gYear (CCYY) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| */ |
| static xmlXPathObjectPtr |
| exsltDateLeapYear (const xmlChar *dateTime) |
| { |
| double year; |
| |
| year = exsltDateYear(dateTime); |
| if (xmlXPathIsNaN(year)) |
| return xmlXPathNewFloat(xmlXPathNAN); |
| |
| if (IS_LEAP((long)year)) |
| return xmlXPathNewBoolean(1); |
| |
| return xmlXPathNewBoolean(0); |
| } |
| |
| /** |
| * exsltDateMonthInYear: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times month-in-year() function: |
| * number date:month-in-year (string?) |
| * Returns the month of a date as a number. If no argument is given, |
| * then the current local date/time, as returned by date:date-time is |
| * used the default argument. |
| * The date/time string specified as the argument is a left or |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * - xs:gYearMonth (CCYY-MM) |
| * - xs:gMonth (--MM--) |
| * - xs:gMonthDay (--MM-DD) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| */ |
| static double |
| exsltDateMonthInYear (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| double ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE) && |
| (dt->type != XS_GYEARMONTH) && (dt->type != XS_GMONTH) && |
| (dt->type != XS_GMONTHDAY)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| ret = (double) dt->value.date.mon; |
| exsltDateFreeDate(dt); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateMonthName: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Time month-name() function |
| * string date:month-name (string?) |
| * Returns the full name of the month of a date. If no argument is |
| * given, then the current local date/time, as returned by |
| * date:date-time is used the default argument. |
| * The date/time string specified as the argument is a left or |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * - xs:gYearMonth (CCYY-MM) |
| * - xs:gMonth (--MM--) |
| * If the date/time string is not in one of these formats, then an |
| * empty string ('') is returned. |
| * The result is an English month name: one of 'January', 'February', |
| * 'March', 'April', 'May', 'June', 'July', 'August', 'September', |
| * 'October', 'November' or 'December'. |
| */ |
| static const xmlChar * |
| exsltDateMonthName (const xmlChar *dateTime) |
| { |
| static const xmlChar monthNames[13][10] = { |
| { 0 }, |
| { 'J', 'a', 'n', 'u', 'a', 'r', 'y', 0 }, |
| { 'F', 'e', 'b', 'r', 'u', 'a', 'r', 'y', 0 }, |
| { 'M', 'a', 'r', 'c', 'h', 0 }, |
| { 'A', 'p', 'r', 'i', 'l', 0 }, |
| { 'M', 'a', 'y', 0 }, |
| { 'J', 'u', 'n', 'e', 0 }, |
| { 'J', 'u', 'l', 'y', 0 }, |
| { 'A', 'u', 'g', 'u', 's', 't', 0 }, |
| { 'S', 'e', 'p', 't', 'e', 'm', 'b', 'e', 'r', 0 }, |
| { 'O', 'c', 't', 'o', 'b', 'e', 'r', 0 }, |
| { 'N', 'o', 'v', 'e', 'm', 'b', 'e', 'r', 0 }, |
| { 'D', 'e', 'c', 'e', 'm', 'b', 'e', 'r', 0 } |
| }; |
| int month; |
| month = (int) exsltDateMonthInYear(dateTime); |
| if (!VALID_MONTH(month)) |
| month = 0; |
| return monthNames[month]; |
| } |
| |
| /** |
| * exsltDateMonthAbbreviation: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Time month-abbreviation() function |
| * string date:month-abbreviation (string?) |
| * Returns the abbreviation of the month of a date. If no argument is |
| * given, then the current local date/time, as returned by |
| * date:date-time is used the default argument. |
| * The date/time string specified as the argument is a left or |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * - xs:gYearMonth (CCYY-MM) |
| * - xs:gMonth (--MM--) |
| * If the date/time string is not in one of these formats, then an |
| * empty string ('') is returned. |
| * The result is an English month abbreviation: one of 'Jan', 'Feb', |
| * 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov' or |
| * 'Dec'. |
| */ |
| static const xmlChar * |
| exsltDateMonthAbbreviation (const xmlChar *dateTime) |
| { |
| static const xmlChar monthAbbreviations[13][4] = { |
| { 0 }, |
| { 'J', 'a', 'n', 0 }, |
| { 'F', 'e', 'b', 0 }, |
| { 'M', 'a', 'r', 0 }, |
| { 'A', 'p', 'r', 0 }, |
| { 'M', 'a', 'y', 0 }, |
| { 'J', 'u', 'n', 0 }, |
| { 'J', 'u', 'l', 0 }, |
| { 'A', 'u', 'g', 0 }, |
| { 'S', 'e', 'p', 0 }, |
| { 'O', 'c', 't', 0 }, |
| { 'N', 'o', 'v', 0 }, |
| { 'D', 'e', 'c', 0 } |
| }; |
| int month; |
| month = (int) exsltDateMonthInYear(dateTime); |
| if(!VALID_MONTH(month)) |
| month = 0; |
| return monthAbbreviations[month]; |
| } |
| |
| /** |
| * exsltDateWeekInYear: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times week-in-year() function |
| * number date:week-in-year (string?) |
| * Returns the week of the year as a number. If no argument is given, |
| * then the current local date/time, as returned by date:date-time is |
| * used as the default argument. For the purposes of numbering, |
| * counting follows ISO 8601: week 1 in a year is the week containing |
| * the first Thursday of the year, with new weeks beginning on a |
| * Monday. |
| * The date/time string specified as the argument is a right-truncated |
| * string in the format defined as the lexical representation of |
| * xs:dateTime in one of the formats defined in [XML Schema Part 2: |
| * Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| */ |
| static double |
| exsltDateWeekInYear (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| long diy, diw, year, ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| diy = DAY_IN_YEAR(dt->value.date.day, dt->value.date.mon, |
| dt->value.date.year); |
| |
| /* |
| * Determine day-in-week (0=Sun, 1=Mon, etc.) then adjust so Monday |
| * is the first day-in-week |
| */ |
| diw = (_exsltDateDayInWeek(diy, dt->value.date.year) + 6) % 7; |
| |
| /* ISO 8601 adjustment, 3 is Thu */ |
| diy += (3 - diw); |
| if(diy < 1) { |
| year = dt->value.date.year - 1; |
| if(year == 0) year--; |
| diy = DAY_IN_YEAR(31, 12, year) + diy; |
| } else if (diy > (long)DAY_IN_YEAR(31, 12, dt->value.date.year)) { |
| diy -= DAY_IN_YEAR(31, 12, dt->value.date.year); |
| } |
| |
| ret = ((diy - 1) / 7) + 1; |
| |
| exsltDateFreeDate(dt); |
| |
| return (double) ret; |
| } |
| |
| /** |
| * exsltDateWeekInMonth: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times week-in-month() function |
| * number date:week-in-month (string?) |
| * The date:week-in-month function returns the week in a month of a |
| * date as a number. If no argument is given, then the current local |
| * date/time, as returned by date:date-time is used the default |
| * argument. For the purposes of numbering, the first day of the month |
| * is in week 1 and new weeks begin on a Monday (so the first and last |
| * weeks in a month will often have less than 7 days in them). |
| * The date/time string specified as the argument is a right-truncated |
| * string in the format defined as the lexical representation of |
| * xs:dateTime in one of the formats defined in [XML Schema Part 2: |
| * Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| */ |
| static double |
| exsltDateWeekInMonth (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| long fdiy, fdiw, ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| fdiy = DAY_IN_YEAR(1, dt->value.date.mon, dt->value.date.year); |
| /* |
| * Determine day-in-week (0=Sun, 1=Mon, etc.) then adjust so Monday |
| * is the first day-in-week |
| */ |
| fdiw = (_exsltDateDayInWeek(fdiy, dt->value.date.year) + 6) % 7; |
| |
| ret = ((dt->value.date.day + fdiw - 1) / 7) + 1; |
| |
| exsltDateFreeDate(dt); |
| |
| return (double) ret; |
| } |
| |
| /** |
| * exsltDateDayInYear: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times day-in-year() function |
| * number date:day-in-year (string?) |
| * Returns the day of a date in a year as a number. If no argument is |
| * given, then the current local date/time, as returned by |
| * date:date-time is used the default argument. |
| * The date/time string specified as the argument is a right-truncated |
| * string in the format defined as the lexical representation of |
| * xs:dateTime in one of the formats defined in [XML Schema Part 2: |
| * Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| */ |
| static double |
| exsltDateDayInYear (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| long ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| ret = DAY_IN_YEAR(dt->value.date.day, dt->value.date.mon, |
| dt->value.date.year); |
| |
| exsltDateFreeDate(dt); |
| |
| return (double) ret; |
| } |
| |
| /** |
| * exsltDateDayInMonth: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times day-in-month() function: |
| * number date:day-in-month (string?) |
| * Returns the day of a date as a number. If no argument is given, |
| * then the current local date/time, as returned by date:date-time is |
| * used the default argument. |
| * The date/time string specified as the argument is a left or |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * - xs:gMonthDay (--MM-DD) |
| * - xs:gDay (---DD) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| */ |
| static double |
| exsltDateDayInMonth (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| double ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE) && |
| (dt->type != XS_GMONTHDAY) && (dt->type != XS_GDAY)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| ret = (double) dt->value.date.day; |
| exsltDateFreeDate(dt); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateDayOfWeekInMonth: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times day-of-week-in-month() function: |
| * number date:day-of-week-in-month (string?) |
| * Returns the day-of-the-week in a month of a date as a number |
| * (e.g. 3 for the 3rd Tuesday in May). If no argument is |
| * given, then the current local date/time, as returned by |
| * date:date-time is used the default argument. |
| * The date/time string specified as the argument is a right-truncated |
| * string in the format defined as the lexical representation of |
| * xs:dateTime in one of the formats defined in [XML Schema Part 2: |
| * Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| */ |
| static double |
| exsltDateDayOfWeekInMonth (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| long ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| ret = ((dt->value.date.day -1) / 7) + 1; |
| |
| exsltDateFreeDate(dt); |
| |
| return (double) ret; |
| } |
| |
| /** |
| * exsltDateDayInWeek: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times day-in-week() function: |
| * number date:day-in-week (string?) |
| * Returns the day of the week given in a date as a number. If no |
| * argument is given, then the current local date/time, as returned by |
| * date:date-time is used the default argument. |
| * The date/time string specified as the argument is a left or |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| * The numbering of days of the week starts at 1 for Sunday, 2 for |
| * Monday and so on up to 7 for Saturday. |
| */ |
| static double |
| exsltDateDayInWeek (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| long diy, ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| diy = DAY_IN_YEAR(dt->value.date.day, dt->value.date.mon, |
| dt->value.date.year); |
| |
| ret = _exsltDateDayInWeek(diy, dt->value.date.year) + 1; |
| |
| exsltDateFreeDate(dt); |
| |
| return (double) ret; |
| } |
| |
| /** |
| * exsltDateDayName: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Time day-name() function |
| * string date:day-name (string?) |
| * Returns the full name of the day of the week of a date. If no |
| * argument is given, then the current local date/time, as returned by |
| * date:date-time is used the default argument. |
| * The date/time string specified as the argument is a left or |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * If the date/time string is not in one of these formats, then an |
| * empty string ('') is returned. |
| * The result is an English day name: one of 'Sunday', 'Monday', |
| * 'Tuesday', 'Wednesday', 'Thursday' or 'Friday'. |
| */ |
| static const xmlChar * |
| exsltDateDayName (const xmlChar *dateTime) |
| { |
| static const xmlChar dayNames[8][10] = { |
| { 0 }, |
| { 'S', 'u', 'n', 'd', 'a', 'y', 0 }, |
| { 'M', 'o', 'n', 'd', 'a', 'y', 0 }, |
| { 'T', 'u', 'e', 's', 'd', 'a', 'y', 0 }, |
| { 'W', 'e', 'd', 'n', 'e', 's', 'd', 'a', 'y', 0 }, |
| { 'T', 'h', 'u', 'r', 's', 'd', 'a', 'y', 0 }, |
| { 'F', 'r', 'i', 'd', 'a', 'y', 0 }, |
| { 'S', 'a', 't', 'u', 'r', 'd', 'a', 'y', 0 } |
| }; |
| int day; |
| day = (int) exsltDateDayInWeek(dateTime); |
| if((day < 1) || (day > 7)) |
| day = 0; |
| return dayNames[day]; |
| } |
| |
| /** |
| * exsltDateDayAbbreviation: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Time day-abbreviation() function |
| * string date:day-abbreviation (string?) |
| * Returns the abbreviation of the day of the week of a date. If no |
| * argument is given, then the current local date/time, as returned by |
| * date:date-time is used the default argument. |
| * The date/time string specified as the argument is a left or |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * If the date/time string is not in one of these formats, then an |
| * empty string ('') is returned. |
| * The result is a three-letter English day abbreviation: one of |
| * 'Sun', 'Mon', 'Tue', 'Wed', 'Thu' or 'Fri'. |
| */ |
| static const xmlChar * |
| exsltDateDayAbbreviation (const xmlChar *dateTime) |
| { |
| static const xmlChar dayAbbreviations[8][4] = { |
| { 0 }, |
| { 'S', 'u', 'n', 0 }, |
| { 'M', 'o', 'n', 0 }, |
| { 'T', 'u', 'e', 0 }, |
| { 'W', 'e', 'd', 0 }, |
| { 'T', 'h', 'u', 0 }, |
| { 'F', 'r', 'i', 0 }, |
| { 'S', 'a', 't', 0 } |
| }; |
| int day; |
| day = (int) exsltDateDayInWeek(dateTime); |
| if((day < 1) || (day > 7)) |
| day = 0; |
| return dayAbbreviations[day]; |
| } |
| |
| /** |
| * exsltDateHourInDay: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times day-in-month() function: |
| * number date:day-in-month (string?) |
| * Returns the hour of the day as a number. If no argument is given, |
| * then the current local date/time, as returned by date:date-time is |
| * used the default argument. |
| * The date/time string specified as the argument is a left or |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:time (hh:mm:ss) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| */ |
| static double |
| exsltDateHourInDay (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| double ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_TIME)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| ret = (double) dt->value.date.hour; |
| exsltDateFreeDate(dt); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateMinuteInHour: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times day-in-month() function: |
| * number date:day-in-month (string?) |
| * Returns the minute of the hour as a number. If no argument is |
| * given, then the current local date/time, as returned by |
| * date:date-time is used the default argument. |
| * The date/time string specified as the argument is a left or |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:time (hh:mm:ss) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| */ |
| static double |
| exsltDateMinuteInHour (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| double ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_TIME)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| ret = (double) dt->value.date.min; |
| exsltDateFreeDate(dt); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateSecondInMinute: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times second-in-minute() function: |
| * number date:day-in-month (string?) |
| * Returns the second of the minute as a number. If no argument is |
| * given, then the current local date/time, as returned by |
| * date:date-time is used the default argument. |
| * The date/time string specified as the argument is a left or |
| * right-truncated string in the format defined as the lexical |
| * representation of xs:dateTime in one of the formats defined in [XML |
| * Schema Part 2: Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:time (hh:mm:ss) |
| * If the date/time string is not in one of these formats, then NaN is |
| * returned. |
| * |
| * Returns the second or NaN. |
| */ |
| static double |
| exsltDateSecondInMinute (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| double ret; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParse(dateTime); |
| if (dt == NULL) |
| return xmlXPathNAN; |
| if ((dt->type != XS_DATETIME) && (dt->type != XS_TIME)) { |
| exsltDateFreeDate(dt); |
| return xmlXPathNAN; |
| } |
| } |
| |
| ret = dt->value.date.sec; |
| exsltDateFreeDate(dt); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateAdd: |
| * @xstr: date/time string |
| * @ystr: date/time string |
| * |
| * Implements the date:add (string,string) function which returns the |
| * date/time * resulting from adding a duration to a date/time. |
| * The first argument (@xstr) must be right-truncated date/time |
| * strings in one of the formats defined in [XML Schema Part 2: |
| * Datatypes]. The permitted formats are as follows: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * - xs:gYearMonth (CCYY-MM) |
| * - xs:gYear (CCYY) |
| * The second argument (@ystr) is a string in the format defined for |
| * xs:duration in [3.2.6 duration] of [XML Schema Part 2: Datatypes]. |
| * The return value is a right-truncated date/time strings in one of |
| * the formats defined in [XML Schema Part 2: Datatypes] and listed |
| * above. This value is calculated using the algorithm described in |
| * [Appendix E Adding durations to dateTimes] of [XML Schema Part 2: |
| * Datatypes]. |
| |
| * Returns date/time string or NULL. |
| */ |
| static xmlChar * |
| exsltDateAdd (const xmlChar *xstr, const xmlChar *ystr) |
| { |
| exsltDateValPtr dt, dur, res; |
| xmlChar *ret; |
| |
| if ((xstr == NULL) || (ystr == NULL)) |
| return NULL; |
| |
| dt = exsltDateParse(xstr); |
| if (dt == NULL) |
| return NULL; |
| else if ((dt->type < XS_GYEAR) || (dt->type > XS_DATETIME)) { |
| exsltDateFreeDate(dt); |
| return NULL; |
| } |
| |
| dur = exsltDateParseDuration(ystr); |
| if (dur == NULL) { |
| exsltDateFreeDate(dt); |
| return NULL; |
| } |
| |
| res = _exsltDateAdd(dt, dur); |
| |
| exsltDateFreeDate(dt); |
| exsltDateFreeDate(dur); |
| |
| if (res == NULL) |
| return NULL; |
| |
| ret = exsltDateFormat(res); |
| exsltDateFreeDate(res); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateAddDuration: |
| * @xstr: first duration string |
| * @ystr: second duration string |
| * |
| * Implements the date:add-duration (string,string) function which returns |
| * the duration resulting from adding two durations together. |
| * Both arguments are strings in the format defined for xs:duration |
| * in [3.2.6 duration] of [XML Schema Part 2: Datatypes]. If either |
| * argument is not in this format, the function returns an empty string |
| * (''). |
| * The return value is a string in the format defined for xs:duration |
| * in [3.2.6 duration] of [XML Schema Part 2: Datatypes]. |
| * The durations can usually be added by summing the numbers given for |
| * each of the components in the durations. However, if the durations |
| * are differently signed, then this sometimes results in durations |
| * that are impossible to express in this syntax (e.g. 'P1M' + '-P1D'). |
| * In these cases, the function returns an empty string (''). |
| * |
| * Returns duration string or NULL. |
| */ |
| static xmlChar * |
| exsltDateAddDuration (const xmlChar *xstr, const xmlChar *ystr) |
| { |
| exsltDateValPtr x, y, res; |
| xmlChar *ret; |
| |
| if ((xstr == NULL) || (ystr == NULL)) |
| return NULL; |
| |
| x = exsltDateParseDuration(xstr); |
| if (x == NULL) |
| return NULL; |
| |
| y = exsltDateParseDuration(ystr); |
| if (y == NULL) { |
| exsltDateFreeDate(x); |
| return NULL; |
| } |
| |
| res = _exsltDateAddDuration(x, y); |
| |
| exsltDateFreeDate(x); |
| exsltDateFreeDate(y); |
| |
| if (res == NULL) |
| return NULL; |
| |
| ret = exsltDateFormatDuration(&(res->value.dur)); |
| exsltDateFreeDate(res); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateSumFunction: |
| * @ns: a node set of duration strings |
| * |
| * The date:sum function adds a set of durations together. |
| * The string values of the nodes in the node set passed as an argument |
| * are interpreted as durations and added together as if using the |
| * date:add-duration function. (from exslt.org) |
| * |
| * The return value is a string in the format defined for xs:duration |
| * in [3.2.6 duration] of [XML Schema Part 2: Datatypes]. |
| * The durations can usually be added by summing the numbers given for |
| * each of the components in the durations. However, if the durations |
| * are differently signed, then this sometimes results in durations |
| * that are impossible to express in this syntax (e.g. 'P1M' + '-P1D'). |
| * In these cases, the function returns an empty string (''). |
| * |
| * Returns duration string or NULL. |
| */ |
| static void |
| exsltDateSumFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlNodeSetPtr ns; |
| void *user = NULL; |
| xmlChar *tmp; |
| exsltDateValPtr x, total; |
| xmlChar *ret; |
| int i; |
| |
| if (nargs != 1) { |
| xmlXPathSetArityError (ctxt); |
| return; |
| } |
| |
| /* We need to delay the freeing of value->user */ |
| if ((ctxt->value != NULL) && ctxt->value->boolval != 0) { |
| user = ctxt->value->user; |
| ctxt->value->boolval = 0; |
| ctxt->value->user = NULL; |
| } |
| |
| ns = xmlXPathPopNodeSet (ctxt); |
| if (xmlXPathCheckError (ctxt)) |
| return; |
| |
| if ((ns == NULL) || (ns->nodeNr == 0)) { |
| xmlXPathReturnEmptyString (ctxt); |
| if (ns != NULL) |
| xmlXPathFreeNodeSet (ns); |
| return; |
| } |
| |
| total = exsltDateCreateDate (XS_DURATION); |
| if (total == NULL) { |
| xmlXPathFreeNodeSet (ns); |
| return; |
| } |
| |
| for (i = 0; i < ns->nodeNr; i++) { |
| int result; |
| tmp = xmlXPathCastNodeToString (ns->nodeTab[i]); |
| if (tmp == NULL) { |
| xmlXPathFreeNodeSet (ns); |
| exsltDateFreeDate (total); |
| return; |
| } |
| |
| x = exsltDateParseDuration (tmp); |
| if (x == NULL) { |
| xmlFree (tmp); |
| exsltDateFreeDate (total); |
| xmlXPathFreeNodeSet (ns); |
| xmlXPathReturnEmptyString (ctxt); |
| return; |
| } |
| |
| result = _exsltDateAddDurCalc(total, total, x); |
| |
| exsltDateFreeDate (x); |
| xmlFree (tmp); |
| if (!result) { |
| exsltDateFreeDate (total); |
| xmlXPathFreeNodeSet (ns); |
| xmlXPathReturnEmptyString (ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateFormatDuration (&(total->value.dur)); |
| exsltDateFreeDate (total); |
| |
| xmlXPathFreeNodeSet (ns); |
| if (user != NULL) |
| xmlFreeNodeList ((xmlNodePtr) user); |
| |
| if (ret == NULL) |
| xmlXPathReturnEmptyString (ctxt); |
| else |
| xmlXPathReturnString (ctxt, ret); |
| } |
| |
| /** |
| * exsltDateSeconds: |
| * @dateTime: a date/time string |
| * |
| * Implements the EXSLT - Dates and Times seconds() function: |
| * number date:seconds(string?) |
| * The date:seconds function returns the number of seconds specified |
| * by the argument string. If no argument is given, then the current |
| * local date/time, as returned by exsltDateCurrent() is used as the |
| * default argument. If the date/time string is a xs:duration, then the |
| * years and months must be zero (or not present). Parsing a duration |
| * converts the fields to seconds. If the date/time string is not a |
| * duration (and not null), then the legal formats are: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * - xs:gYearMonth (CCYY-MM) |
| * - xs:gYear (CCYY) |
| * In these cases the difference between the @dateTime and |
| * 1970-01-01T00:00:00Z is calculated and converted to seconds. |
| * |
| * Note that there was some confusion over whether "difference" meant |
| * that a dateTime of 1970-01-01T00:00:01Z should be a positive one or |
| * a negative one. After correspondence with exslt.org, it was determined |
| * that the intent of the specification was to have it positive. The |
| * coding was modified in July 2003 to reflect this. |
| * |
| * Returns seconds or Nan. |
| */ |
| static double |
| exsltDateSeconds (const xmlChar *dateTime) |
| { |
| exsltDateValPtr dt; |
| double ret = xmlXPathNAN; |
| |
| if (dateTime == NULL) { |
| #ifdef WITH_TIME |
| dt = exsltDateCurrent(); |
| if (dt == NULL) |
| #endif |
| return xmlXPathNAN; |
| } else { |
| dt = exsltDateParseDuration(dateTime); |
| if (dt == NULL) |
| dt = exsltDateParse(dateTime); |
| } |
| |
| if (dt == NULL) |
| return xmlXPathNAN; |
| |
| if ((dt->type <= XS_DATETIME) && (dt->type >= XS_GYEAR)) { |
| exsltDateValPtr y, dur; |
| |
| /* |
| * compute the difference between the given (or current) date |
| * and epoch date |
| */ |
| y = exsltDateCreateDate(XS_DATETIME); |
| if (y != NULL) { |
| y->value.date.year = 1970; |
| y->value.date.mon = 1; |
| y->value.date.day = 1; |
| y->value.date.tz_flag = 1; |
| |
| dur = _exsltDateDifference(y, dt, 1); |
| if (dur != NULL) { |
| ret = exsltDateCastDateToNumber(dur); |
| exsltDateFreeDate(dur); |
| } |
| exsltDateFreeDate(y); |
| } |
| |
| } else if ((dt->type == XS_DURATION) && (dt->value.dur.mon == 0)) |
| ret = exsltDateCastDateToNumber(dt); |
| |
| exsltDateFreeDate(dt); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateDifference: |
| * @xstr: date/time string |
| * @ystr: date/time string |
| * |
| * Implements the date:difference (string,string) function which returns |
| * the duration between the first date and the second date. If the first |
| * date occurs before the second date, then the result is a positive |
| * duration; if it occurs after the second date, the result is a |
| * negative duration. The two dates must both be right-truncated |
| * date/time strings in one of the formats defined in [XML Schema Part |
| * 2: Datatypes]. The date/time with the most specific format (i.e. the |
| * least truncation) is converted into the same format as the date with |
| * the least specific format (i.e. the most truncation). The permitted |
| * formats are as follows, from most specific to least specific: |
| * - xs:dateTime (CCYY-MM-DDThh:mm:ss) |
| * - xs:date (CCYY-MM-DD) |
| * - xs:gYearMonth (CCYY-MM) |
| * - xs:gYear (CCYY) |
| * If either of the arguments is not in one of these formats, |
| * date:difference returns the empty string (''). |
| * The difference between the date/times is returned as a string in the |
| * format defined for xs:duration in [3.2.6 duration] of [XML Schema |
| * Part 2: Datatypes]. |
| * If the date/time string with the least specific format is in either |
| * xs:gYearMonth or xs:gYear format, then the number of days, hours, |
| * minutes and seconds in the duration string must be equal to zero. |
| * (The format of the string will be PnYnM.) The number of months |
| * specified in the duration must be less than 12. |
| * Otherwise, the number of years and months in the duration string |
| * must be equal to zero. (The format of the string will be |
| * PnDTnHnMnS.) The number of seconds specified in the duration string |
| * must be less than 60; the number of minutes must be less than 60; |
| * the number of hours must be less than 24. |
| * |
| * Returns duration string or NULL. |
| */ |
| static xmlChar * |
| exsltDateDifference (const xmlChar *xstr, const xmlChar *ystr) |
| { |
| exsltDateValPtr x, y, dur; |
| xmlChar *ret = NULL; |
| |
| if ((xstr == NULL) || (ystr == NULL)) |
| return NULL; |
| |
| x = exsltDateParse(xstr); |
| if (x == NULL) |
| return NULL; |
| |
| y = exsltDateParse(ystr); |
| if (y == NULL) { |
| exsltDateFreeDate(x); |
| return NULL; |
| } |
| |
| if (((x->type < XS_GYEAR) || (x->type > XS_DATETIME)) || |
| ((y->type < XS_GYEAR) || (y->type > XS_DATETIME))) { |
| exsltDateFreeDate(x); |
| exsltDateFreeDate(y); |
| return NULL; |
| } |
| |
| dur = _exsltDateDifference(x, y, 0); |
| |
| exsltDateFreeDate(x); |
| exsltDateFreeDate(y); |
| |
| if (dur == NULL) |
| return NULL; |
| |
| ret = exsltDateFormatDuration(&(dur->value.dur)); |
| exsltDateFreeDate(dur); |
| |
| return ret; |
| } |
| |
| /** |
| * exsltDateDuration: |
| * @number: a xmlChar string |
| * |
| * Implements the The date:duration function returns a duration string |
| * representing the number of seconds specified by the argument string. |
| * If no argument is given, then the result of calling date:seconds |
| * without any arguments is used as a default argument. |
| * The duration is returned as a string in the format defined for |
| * xs:duration in [3.2.6 duration] of [XML Schema Part 2: Datatypes]. |
| * The number of years and months in the duration string must be equal |
| * to zero. (The format of the string will be PnDTnHnMnS.) The number |
| * of seconds specified in the duration string must be less than 60; |
| * the number of minutes must be less than 60; the number of hours must |
| * be less than 24. |
| * If the argument is Infinity, -Infinity or NaN, then date:duration |
| * returns an empty string (''). |
| * |
| * Returns duration string or NULL. |
| */ |
| static xmlChar * |
| exsltDateDuration (const xmlChar *number) |
| { |
| exsltDateValPtr dur; |
| double secs; |
| xmlChar *ret; |
| |
| if (number == NULL) |
| secs = exsltDateSeconds(number); |
| else |
| secs = xmlXPathCastStringToNumber(number); |
| |
| if ((xmlXPathIsNaN(secs)) || (xmlXPathIsInf(secs))) |
| return NULL; |
| |
| dur = exsltDateCreateDate(XS_DURATION); |
| if (dur == NULL) |
| return NULL; |
| |
| dur->value.dur.sec = secs; |
| |
| ret = exsltDateFormatDuration(&(dur->value.dur)); |
| exsltDateFreeDate(dur); |
| |
| return ret; |
| } |
| |
| /**************************************************************** |
| * * |
| * Wrappers for use by the XPath engine * |
| * * |
| ****************************************************************/ |
| |
| #ifdef WITH_TIME |
| /** |
| * exsltDateDateTimeFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateDateTime() for use by the XPath engine. |
| */ |
| static void |
| exsltDateDateTimeFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *ret; |
| |
| if (nargs != 0) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| |
| ret = exsltDateDateTime(); |
| if (ret == NULL) |
| xmlXPathReturnEmptyString(ctxt); |
| else |
| xmlXPathReturnString(ctxt, ret); |
| } |
| #endif |
| |
| /** |
| * exsltDateDateFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateDate() for use by the XPath engine. |
| */ |
| static void |
| exsltDateDateFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *ret, *dt = NULL; |
| |
| if ((nargs < 0) || (nargs > 1)) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| if (nargs == 1) { |
| dt = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlXPathSetTypeError(ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateDate(dt); |
| |
| if (ret == NULL) { |
| xsltGenericDebug(xsltGenericDebugContext, |
| "{http://exslt.org/dates-and-times}date: " |
| "invalid date or format %s\n", dt); |
| xmlXPathReturnEmptyString(ctxt); |
| } else { |
| xmlXPathReturnString(ctxt, ret); |
| } |
| |
| if (dt != NULL) |
| xmlFree(dt); |
| } |
| |
| /** |
| * exsltDateTimeFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateTime() for use by the XPath engine. |
| */ |
| static void |
| exsltDateTimeFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *ret, *dt = NULL; |
| |
| if ((nargs < 0) || (nargs > 1)) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| if (nargs == 1) { |
| dt = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlXPathSetTypeError(ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateTime(dt); |
| |
| if (ret == NULL) { |
| xsltGenericDebug(xsltGenericDebugContext, |
| "{http://exslt.org/dates-and-times}time: " |
| "invalid date or format %s\n", dt); |
| xmlXPathReturnEmptyString(ctxt); |
| } else { |
| xmlXPathReturnString(ctxt, ret); |
| } |
| |
| if (dt != NULL) |
| xmlFree(dt); |
| } |
| |
| /** |
| * exsltDateYearFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateYear() for use by the XPath engine. |
| */ |
| static void |
| exsltDateYearFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *dt = NULL; |
| double ret; |
| |
| if ((nargs < 0) || (nargs > 1)) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| |
| if (nargs == 1) { |
| dt = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlXPathSetTypeError(ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateYear(dt); |
| |
| if (dt != NULL) |
| xmlFree(dt); |
| |
| xmlXPathReturnNumber(ctxt, ret); |
| } |
| |
| /** |
| * exsltDateLeapYearFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateLeapYear() for use by the XPath engine. |
| */ |
| static void |
| exsltDateLeapYearFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *dt = NULL; |
| xmlXPathObjectPtr ret; |
| |
| if ((nargs < 0) || (nargs > 1)) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| |
| if (nargs == 1) { |
| dt = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlXPathSetTypeError(ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateLeapYear(dt); |
| |
| if (dt != NULL) |
| xmlFree(dt); |
| |
| valuePush(ctxt, ret); |
| } |
| |
| #define X_IN_Y(x, y) \ |
| static void \ |
| exsltDate##x##In##y##Function (xmlXPathParserContextPtr ctxt, \ |
| int nargs) { \ |
| xmlChar *dt = NULL; \ |
| double ret; \ |
| \ |
| if ((nargs < 0) || (nargs > 1)) { \ |
| xmlXPathSetArityError(ctxt); \ |
| return; \ |
| } \ |
| \ |
| if (nargs == 1) { \ |
| dt = xmlXPathPopString(ctxt); \ |
| if (xmlXPathCheckError(ctxt)) { \ |
| xmlXPathSetTypeError(ctxt); \ |
| return; \ |
| } \ |
| } \ |
| \ |
| ret = exsltDate##x##In##y(dt); \ |
| \ |
| if (dt != NULL) \ |
| xmlFree(dt); \ |
| \ |
| xmlXPathReturnNumber(ctxt, ret); \ |
| } |
| |
| /** |
| * exsltDateMonthInYearFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateMonthInYear() for use by the XPath engine. |
| */ |
| X_IN_Y(Month,Year) |
| |
| /** |
| * exsltDateMonthNameFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateMonthName() for use by the XPath engine. |
| */ |
| static void |
| exsltDateMonthNameFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *dt = NULL; |
| const xmlChar *ret; |
| |
| if ((nargs < 0) || (nargs > 1)) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| |
| if (nargs == 1) { |
| dt = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlXPathSetTypeError(ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateMonthName(dt); |
| |
| if (dt != NULL) |
| xmlFree(dt); |
| |
| if (ret == NULL) |
| xmlXPathReturnEmptyString(ctxt); |
| else |
| xmlXPathReturnString(ctxt, xmlStrdup(ret)); |
| } |
| |
| /** |
| * exsltDateMonthAbbreviationFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateMonthAbbreviation() for use by the XPath engine. |
| */ |
| static void |
| exsltDateMonthAbbreviationFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *dt = NULL; |
| const xmlChar *ret; |
| |
| if ((nargs < 0) || (nargs > 1)) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| |
| if (nargs == 1) { |
| dt = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlXPathSetTypeError(ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateMonthAbbreviation(dt); |
| |
| if (dt != NULL) |
| xmlFree(dt); |
| |
| if (ret == NULL) |
| xmlXPathReturnEmptyString(ctxt); |
| else |
| xmlXPathReturnString(ctxt, xmlStrdup(ret)); |
| } |
| |
| /** |
| * exsltDateWeekInYearFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateWeekInYear() for use by the XPath engine. |
| */ |
| X_IN_Y(Week,Year) |
| |
| /** |
| * exsltDateWeekInMonthFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateWeekInMonthYear() for use by the XPath engine. |
| */ |
| X_IN_Y(Week,Month) |
| |
| /** |
| * exsltDateDayInYearFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateDayInYear() for use by the XPath engine. |
| */ |
| X_IN_Y(Day,Year) |
| |
| /** |
| * exsltDateDayInMonthFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateDayInMonth() for use by the XPath engine. |
| */ |
| X_IN_Y(Day,Month) |
| |
| /** |
| * exsltDateDayOfWeekInMonthFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDayOfWeekInMonth() for use by the XPath engine. |
| */ |
| X_IN_Y(DayOfWeek,Month) |
| |
| /** |
| * exsltDateDayInWeekFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateDayInWeek() for use by the XPath engine. |
| */ |
| X_IN_Y(Day,Week) |
| |
| /** |
| * exsltDateDayNameFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateDayName() for use by the XPath engine. |
| */ |
| static void |
| exsltDateDayNameFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *dt = NULL; |
| const xmlChar *ret; |
| |
| if ((nargs < 0) || (nargs > 1)) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| |
| if (nargs == 1) { |
| dt = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlXPathSetTypeError(ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateDayName(dt); |
| |
| if (dt != NULL) |
| xmlFree(dt); |
| |
| if (ret == NULL) |
| xmlXPathReturnEmptyString(ctxt); |
| else |
| xmlXPathReturnString(ctxt, xmlStrdup(ret)); |
| } |
| |
| /** |
| * exsltDateMonthDayFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateDayAbbreviation() for use by the XPath engine. |
| */ |
| static void |
| exsltDateDayAbbreviationFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *dt = NULL; |
| const xmlChar *ret; |
| |
| if ((nargs < 0) || (nargs > 1)) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| |
| if (nargs == 1) { |
| dt = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlXPathSetTypeError(ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateDayAbbreviation(dt); |
| |
| if (dt != NULL) |
| xmlFree(dt); |
| |
| if (ret == NULL) |
| xmlXPathReturnEmptyString(ctxt); |
| else |
| xmlXPathReturnString(ctxt, xmlStrdup(ret)); |
| } |
| |
| |
| /** |
| * exsltDateHourInDayFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateHourInDay() for use by the XPath engine. |
| */ |
| X_IN_Y(Hour,Day) |
| |
| /** |
| * exsltDateMinuteInHourFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateMinuteInHour() for use by the XPath engine. |
| */ |
| X_IN_Y(Minute,Hour) |
| |
| /** |
| * exsltDateSecondInMinuteFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateSecondInMinute() for use by the XPath engine. |
| */ |
| X_IN_Y(Second,Minute) |
| |
| /** |
| * exsltDateSecondsFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateSeconds() for use by the XPath engine. |
| */ |
| static void |
| exsltDateSecondsFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *str = NULL; |
| double ret; |
| |
| if (nargs > 1) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| |
| if (nargs == 1) { |
| str = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlXPathSetTypeError(ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateSeconds(str); |
| if (str != NULL) |
| xmlFree(str); |
| |
| xmlXPathReturnNumber(ctxt, ret); |
| } |
| |
| /** |
| * exsltDateAddFunction: |
| * @ctxt: an XPath parser context |
| * @nargs: the number of arguments |
| * |
| * Wraps exsltDateAdd() for use by the XPath processor. |
| */ |
| static void |
| exsltDateAddFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *ret, *xstr, *ystr; |
| |
| if (nargs != 2) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| ystr = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) |
| return; |
| |
| xstr = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlFree(ystr); |
| return; |
| } |
| |
| ret = exsltDateAdd(xstr, ystr); |
| |
| xmlFree(ystr); |
| xmlFree(xstr); |
| |
| if (ret == NULL) |
| xmlXPathReturnEmptyString(ctxt); |
| else |
| xmlXPathReturnString(ctxt, ret); |
| } |
| |
| /** |
| * exsltDateAddDurationFunction: |
| * @ctxt: an XPath parser context |
| * @nargs: the number of arguments |
| * |
| * Wraps exsltDateAddDuration() for use by the XPath processor. |
| */ |
| static void |
| exsltDateAddDurationFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *ret, *xstr, *ystr; |
| |
| if (nargs != 2) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| ystr = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) |
| return; |
| |
| xstr = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlFree(ystr); |
| return; |
| } |
| |
| ret = exsltDateAddDuration(xstr, ystr); |
| |
| xmlFree(ystr); |
| xmlFree(xstr); |
| |
| if (ret == NULL) |
| xmlXPathReturnEmptyString(ctxt); |
| else |
| xmlXPathReturnString(ctxt, ret); |
| } |
| |
| /** |
| * exsltDateDifferenceFunction: |
| * @ctxt: an XPath parser context |
| * @nargs: the number of arguments |
| * |
| * Wraps exsltDateDifference() for use by the XPath processor. |
| */ |
| static void |
| exsltDateDifferenceFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *ret, *xstr, *ystr; |
| |
| if (nargs != 2) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| ystr = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) |
| return; |
| |
| xstr = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlFree(ystr); |
| return; |
| } |
| |
| ret = exsltDateDifference(xstr, ystr); |
| |
| xmlFree(ystr); |
| xmlFree(xstr); |
| |
| if (ret == NULL) |
| xmlXPathReturnEmptyString(ctxt); |
| else |
| xmlXPathReturnString(ctxt, ret); |
| } |
| |
| /** |
| * exsltDateDurationFunction: |
| * @ctxt: an XPath parser context |
| * @nargs : the number of arguments |
| * |
| * Wraps exsltDateDuration() for use by the XPath engine |
| */ |
| static void |
| exsltDateDurationFunction (xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| xmlChar *ret; |
| xmlChar *number = NULL; |
| |
| if ((nargs < 0) || (nargs > 1)) { |
| xmlXPathSetArityError(ctxt); |
| return; |
| } |
| |
| if (nargs == 1) { |
| number = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) { |
| xmlXPathSetTypeError(ctxt); |
| return; |
| } |
| } |
| |
| ret = exsltDateDuration(number); |
| |
| if (number != NULL) |
| xmlFree(number); |
| |
| if (ret == NULL) |
| xmlXPathReturnEmptyString(ctxt); |
| else |
| xmlXPathReturnString(ctxt, ret); |
| } |
| |
| /** |
| * exsltDateRegister: |
| * |
| * Registers the EXSLT - Dates and Times module |
| */ |
| void |
| exsltDateRegister (void) |
| { |
| xsltRegisterExtModuleFunction ((const xmlChar *) "add", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateAddFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "add-duration", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateAddDurationFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "date", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDateFunction); |
| #ifdef WITH_TIME |
| xsltRegisterExtModuleFunction ((const xmlChar *) "date-time", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDateTimeFunction); |
| #endif |
| xsltRegisterExtModuleFunction ((const xmlChar *) "day-abbreviation", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayAbbreviationFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "day-in-month", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayInMonthFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "day-in-week", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayInWeekFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "day-in-year", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayInYearFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "day-name", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayNameFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "day-of-week-in-month", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayOfWeekInMonthFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "difference", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDifferenceFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "duration", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDurationFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "hour-in-day", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateHourInDayFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "leap-year", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateLeapYearFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "minute-in-hour", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateMinuteInHourFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "month-abbreviation", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateMonthAbbreviationFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "month-in-year", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateMonthInYearFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "month-name", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateMonthNameFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "second-in-minute", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateSecondInMinuteFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "seconds", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateSecondsFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "sum", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateSumFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "time", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateTimeFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "week-in-month", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateWeekInMonthFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "week-in-year", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateWeekInYearFunction); |
| xsltRegisterExtModuleFunction ((const xmlChar *) "year", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateYearFunction); |
| } |
| |
| /** |
| * exsltDateXpathCtxtRegister: |
| * |
| * Registers the EXSLT - Dates and Times module for use outside XSLT |
| */ |
| int |
| exsltDateXpathCtxtRegister (xmlXPathContextPtr ctxt, const xmlChar *prefix) |
| { |
| if (ctxt |
| && prefix |
| && !xmlXPathRegisterNs(ctxt, |
| prefix, |
| (const xmlChar *) EXSLT_DATE_NAMESPACE) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "add", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateAddFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "add-duration", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateAddDurationFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "date", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDateFunction) |
| #ifdef WITH_TIME |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "date-time", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDateTimeFunction) |
| #endif |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "day-abbreviation", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayAbbreviationFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "day-in-month", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayInMonthFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "day-in-week", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayInWeekFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "day-in-year", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayInYearFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "day-name", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayNameFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "day-of-week-in-month", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDayOfWeekInMonthFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "difference", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDifferenceFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "duration", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateDurationFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "hour-in-day", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateHourInDayFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "leap-year", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateLeapYearFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "minute-in-hour", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateMinuteInHourFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "month-abbreviation", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateMonthAbbreviationFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "month-in-year", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateMonthInYearFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "month-name", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateMonthNameFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "second-in-minute", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateSecondInMinuteFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "seconds", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateSecondsFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "sum", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateSumFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "time", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateTimeFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "week-in-month", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateWeekInMonthFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "week-in-year", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateWeekInYearFunction) |
| && !xmlXPathRegisterFuncNS(ctxt, |
| (const xmlChar *) "year", |
| (const xmlChar *) EXSLT_DATE_NAMESPACE, |
| exsltDateYearFunction)) { |
| return 0; |
| } |
| return -1; |
| } |