Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxslt/libexslt/date.c

 /*
  * 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>
@@ skipping 10 matching lines @@
 
 #define IN_LIBEXSLT
 #include "libexslt/libexslt.h"
 
 #if defined(WIN32) && !defined (__CYGWIN__) && (!__MINGW32__)
 #include <win32config.h>
 #else
 #include "config.h"
 #endif
 
-#if HAVE_LOCALTIME_R    /* _POSIX_SOURCE required by gnu libc */
+#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>
@@ skipping 50 matching lines @@
     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;
+    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)                                        \
+#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                *
  *                                                              *
@@ skipping 651 matching lines @@
 #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;
+        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;
+        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;
+        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;
+        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;
+        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;
+        ret->value.date.tzo = ((SECS_PER_DAY - gm_s) + local_s)/60;
     } else  {
-        ret->value.date.tzo = (local_s - gm_s)/60;
+        ret->value.date.tzo = (local_s - gm_s)/60;
     }
- 
+
     return ret;
 }
 #endif
 
 /**
  * exsltDateParse:
  * @dateTime:  string to analyze
  *
  * Parses a date/time string
  *
@@ skipping 279 matching lines @@
 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)) 
+    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) {
@@ skipping 149 matching lines @@
         return xmlStrdup(buf);
     }
 
     return NULL;
 }
 
 /**
  * _exsltDateCastYMToDays:
  * @dt: an #exsltDateValPtr
  *
- * Convert mon and year of @dt to total number of days. Take the 
+ * 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;
@@ skipping 92 matching lines @@
 
     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 
+ * 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) 
+        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
  */
@@ skipping 93 matching lines @@
 
     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 
+             * 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->mon != 1) && (r->day != 1))
+            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))
+    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;
 
@@ skipping 19 matching lines @@
  */
 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))) 
+        ((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) {
@@ skipping 116 matching lines @@
  *                                                              *
  *              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 *
@@ skipping 23 matching lines @@
 
     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 *
@@ skipping 760 matching lines @@
  * 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
@@ skipping 16 matching lines @@
 
     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. 
+ * 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) 
+ * 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]. 
+ * 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]. 
+ * Datatypes].
 
  * Returns date/time string or NULL.
  */
 static xmlChar *
 exsltDateAdd (const xmlChar *xstr, const xmlChar *ystr)
 {
     exsltDateValPtr dt, dur, res;
-    xmlChar     *ret;   
+    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;
@@ skipping 18 matching lines @@
 
     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. 
+ * 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]. 
+ * 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 (''). 
+ * 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;   
+    xmlChar     *ret;
 
     if ((xstr == NULL) || (ystr == NULL))
         return NULL;
 
     x = exsltDateParseDuration(xstr);
     if (x == NULL)
         return NULL;
 
     y = exsltDateParseDuration(ystr);
     if (y == NULL) {
@@ skipping 12 matching lines @@
     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 
+ * 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]. 
+ * 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 (''). 
+ * 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;
@@ skipping 23 matching lines @@
         return;
     }
 
     total = exsltDateCreateDate (XS_DURATION);
     if (total == NULL) {
         xmlXPathFreeNodeSet (ns);
         return;
     }
 
     for (i = 0; i < ns->nodeNr; i++) {
-        int result;
+        int result;
         tmp = xmlXPathCastNodeToString (ns->nodeTab[i]);
         if (tmp == NULL) {
             xmlXPathFreeNodeSet (ns);
             exsltDateFreeDate (total);
             return;
         }
 
         x = exsltDateParseDuration (tmp);
         if (x == NULL) {
             xmlFree (tmp);
@@ skipping 32 matching lines @@
  * 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 
+ * 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 
+ * 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.
  */
@@ skipping 27 matching lines @@
          */
         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); 
+                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) 
+ * 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 (''). 
+ * 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]. 
+ * 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. 
+ * 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. 
+ * 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;   
+    xmlChar        *ret = NULL;
 
     if ((xstr == NULL) || (ystr == NULL))
         return NULL;
 
     x = exsltDateParse(xstr);
     if (x == NULL)
         return NULL;
 
     y = exsltDateParse(ystr);
     if (y == NULL) {
@@ skipping 22 matching lines @@
     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. 
+ * 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]. 
+ * 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. 
+ * be less than 24.
  * If the argument is Infinity, -Infinity or NaN, then date:duration
- * returns an empty string (''). 
+ * returns an empty string ('').
  *
  * Returns duration string or NULL.
  */
 static xmlChar *
 exsltDateDuration (const xmlChar *number)
 {
     exsltDateValPtr dur;
     double       secs;
     xmlChar     *ret;
 
@@ skipping 842 matching lines @@
                                    (const xmlChar *) EXSLT_DATE_NAMESPACE,
                                    exsltDateWeekInYearFunction)
         && !xmlXPathRegisterFuncNS(ctxt,
                                    (const xmlChar *) "year",
                                    (const xmlChar *) EXSLT_DATE_NAMESPACE,
                                    exsltDateYearFunction)) {
         return 0;
     }
     return -1;
 }