Coverage Report

Created: 2024-01-20 12:31

/src/libxslt/libexslt/date.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * date.c: Implementation of the EXSLT -- Dates and Times module
3
 *
4
 * References:
5
 *   http://www.exslt.org/date/date.html
6
 *
7
 * See Copyright for the status of this software.
8
 *
9
 * Authors:
10
 *   Charlie Bozeman <cbozeman@HiWAAY.net>
11
 *   Thomas Broyer <tbroyer@ltgt.net>
12
 *
13
 * TODO:
14
 * elements:
15
 *   date-format
16
 * functions:
17
 *   format-date
18
 *   parse-date
19
 *   sum
20
 */
21
22
#define IN_LIBEXSLT
23
#include "libexslt/libexslt.h"
24
25
#if defined(HAVE_LOCALTIME_R) && defined(__GLIBC__) /* _POSIX_SOURCE required by gnu libc */
26
#ifndef _AIX51    /* but on AIX we're not using gnu libc */
27
#define _POSIX_SOURCE
28
#endif
29
#endif
30
31
#include <libxml/tree.h>
32
#include <libxml/xpath.h>
33
#include <libxml/xpathInternals.h>
34
35
#include <libxslt/xsltutils.h>
36
#include <libxslt/xsltInternals.h>
37
#include <libxslt/extensions.h>
38
39
#include "exslt.h"
40
41
#include <string.h>
42
#include <limits.h>
43
#include <errno.h>
44
#include <math.h>
45
46
/* needed to get localtime_r on Solaris */
47
#ifdef __sun
48
#ifndef __EXTENSIONS__
49
#define __EXTENSIONS__
50
#endif
51
#endif
52
53
#include <time.h>
54
55
/*
56
 * types of date and/or time (from schema datatypes)
57
 *   somewhat ordered from least specific to most specific (i.e.
58
 *   most truncated to least truncated).
59
 */
60
typedef enum {
61
    EXSLT_UNKNOWN  =    0,
62
    XS_TIME        =    1,       /* time is left-truncated */
63
    XS_GDAY        = (XS_TIME   << 1),
64
    XS_GMONTH      = (XS_GDAY   << 1),
65
    XS_GMONTHDAY   = (XS_GMONTH | XS_GDAY),
66
    XS_GYEAR       = (XS_GMONTH << 1),
67
    XS_GYEARMONTH  = (XS_GYEAR  | XS_GMONTH),
68
    XS_DATE        = (XS_GYEAR  | XS_GMONTH | XS_GDAY),
69
    XS_DATETIME    = (XS_DATE   | XS_TIME)
70
} exsltDateType;
71
72
/* Date value */
73
typedef struct _exsltDateVal exsltDateVal;
74
typedef exsltDateVal *exsltDateValPtr;
75
struct _exsltDateVal {
76
    exsltDateType type;
77
    long    year;
78
    unsigned int  mon :4; /* 1 <=  mon    <= 12   */
79
    unsigned int  day :5; /* 1 <=  day    <= 31   */
80
    unsigned int  hour  :5; /* 0 <=  hour   <= 23   */
81
    unsigned int  min :6; /* 0 <=  min    <= 59 */
82
    double    sec;
83
    unsigned int  tz_flag :1; /* is tzo explicitely set? */
84
    signed int    tzo :12;  /* -1440 <= tzo <= 1440 currently only -840 to +840 are needed */
85
};
86
87
/* Duration value */
88
typedef struct _exsltDateDurVal exsltDateDurVal;
89
typedef exsltDateDurVal *exsltDateDurValPtr;
90
struct _exsltDateDurVal {
91
    long  mon;  /* mon stores years also */
92
    long  day;
93
    double  sec;  /* sec stores min and hour also
94
         0 <= sec < SECS_PER_DAY */
95
};
96
97
/****************************************************************
98
 *                *
99
 *    Convenience macros and functions    *
100
 *                *
101
 ****************************************************************/
102
103
#define IS_TZO_CHAR(c)            \
104
24.1k
  ((c == 0) || (c == 'Z') || (c == '+') || (c == '-'))
105
106
4.30k
#define VALID_ALWAYS(num) (num >= 0)
107
20.8k
#define VALID_MONTH(mon)        ((mon >= 1) && (mon <= 12))
108
/* VALID_DAY should only be used when month is unknown */
109
5.78k
#define VALID_DAY(day)          ((day >= 1) && (day <= 31))
110
33.1k
#define VALID_HOUR(hr)          ((hr >= 0) && (hr <= 23))
111
5.44k
#define VALID_MIN(min)          ((min >= 0) && (min <= 59))
112
10.5k
#define VALID_SEC(sec)          ((sec >= 0) && (sec < 60))
113
6.13k
#define VALID_TZO(tzo)          ((tzo > -1440) && (tzo < 1440))
114
#define IS_LEAP(y)            \
115
110k
  (((y & 3) == 0) && ((y % 25 != 0) || ((y & 15) == 0)))
116
117
static const long daysInMonth[12] =
118
  { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
119
static const long daysInMonthLeap[12] =
120
  { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
121
122
#define MAX_DAYINMONTH(yr,mon)                                  \
123
103k
        (IS_LEAP(yr) ? daysInMonthLeap[mon - 1] : daysInMonth[mon - 1])
124
125
#define VALID_MDAY(dt)            \
126
6.74k
  (IS_LEAP(dt->year) ?                \
127
6.74k
      (dt->day <= daysInMonthLeap[dt->mon - 1]) :          \
128
6.74k
      (dt->day <= daysInMonth[dt->mon - 1]))
129
130
#define VALID_DATE(dt)            \
131
7.94k
  (VALID_MONTH(dt->mon) && VALID_MDAY(dt))
132
133
/*
134
    hour and min structure vals are unsigned, so normal macros give
135
    warnings on some compilers.
136
*/
137
#define VALID_TIME(dt)            \
138
5.27k
  ((dt->hour <=23 ) && (dt->min <= 59) &&     \
139
5.27k
   VALID_SEC(dt->sec) && VALID_TZO(dt->tzo))
140
141
#define VALID_DATETIME(dt)          \
142
1.20k
  (VALID_DATE(dt) && VALID_TIME(dt))
143
144
19.7k
#define SECS_PER_MIN            60
145
20.0k
#define MINS_PER_HOUR           60
146
20.7k
#define HOURS_PER_DAY           24
147
16.0k
#define SECS_PER_HOUR           (MINS_PER_HOUR * SECS_PER_MIN)
148
12.2k
#define SECS_PER_DAY            (HOURS_PER_DAY * SECS_PER_HOUR)
149
4.01k
#define MINS_PER_DAY            (HOURS_PER_DAY * MINS_PER_HOUR)
150
538
#define DAYS_PER_EPOCH          (400 * 365 + 100 - 4 + 1)
151
269
#define YEARS_PER_EPOCH         400
152
153
static const long dayInYearByMonth[12] =
154
  { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
155
static const long dayInLeapYearByMonth[12] =
156
  { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 };
157
158
#define DAY_IN_YEAR(day, month, year)       \
159
517
        ((IS_LEAP(year) ?          \
160
517
                dayInLeapYearByMonth[month - 1] :    \
161
517
                dayInYearByMonth[month - 1]) + day)
162
163
64.1k
#define YEAR_MAX LONG_MAX
164
8.82k
#define YEAR_MIN (-LONG_MAX + 1)
165
166
/**
167
 * _exsltDateParseGYear:
168
 * @dt:  pointer to a date structure
169
 * @str: pointer to the string to analyze
170
 *
171
 * Parses a xs:gYear without time zone and fills in the appropriate
172
 * field of the @dt structure. @str is updated to point just after the
173
 * xs:gYear. It is supposed that @dt->year is big enough to contain
174
 * the year.
175
 *
176
 * According to XML Schema Part 2, the year "0000" is an illegal year value
177
 * which probably means that the year preceding AD 1 is BC 1. Internally,
178
 * we allow a year 0 and adjust the value when parsing and formatting.
179
 *
180
 * Returns 0 or the error code
181
 */
182
static int
183
_exsltDateParseGYear (exsltDateValPtr dt, const xmlChar **str)
184
13.3k
{
185
13.3k
    const xmlChar *cur = *str, *firstChar;
186
13.3k
    int isneg = 0, digcnt = 0;
187
188
13.3k
    if (((*cur < '0') || (*cur > '9')) &&
189
13.3k
  (*cur != '-') && (*cur != '+'))
190
328
  return -1;
191
192
13.0k
    if (*cur == '-') {
193
74
  isneg = 1;
194
74
  cur++;
195
74
    }
196
197
13.0k
    firstChar = cur;
198
199
77.1k
    while ((*cur >= '0') && (*cur <= '9')) {
200
64.1k
        if (dt->year >= YEAR_MAX / 10) /* Not really exact */
201
15
            return -1;
202
64.1k
  dt->year = dt->year * 10 + (*cur - '0');
203
64.1k
  cur++;
204
64.1k
  digcnt++;
205
64.1k
    }
206
207
    /* year must be at least 4 digits (CCYY); over 4
208
     * digits cannot have a leading zero. */
209
13.0k
    if ((digcnt < 4) || ((digcnt > 4) && (*firstChar == '0')))
210
1.86k
  return 1;
211
212
11.1k
    if (dt->year == 0)
213
15
  return 2;
214
215
    /* The internal representation of negative years is continuous. */
216
11.1k
    if (isneg)
217
27
  dt->year = -dt->year + 1;
218
219
11.1k
    *str = cur;
220
221
#ifdef DEBUG_EXSLT_DATE
222
    xsltGenericDebug(xsltGenericDebugContext,
223
         "Parsed year %04ld\n", dt->year);
224
#endif
225
226
11.1k
    return 0;
227
11.1k
}
228
229
/**
230
 * FORMAT_GYEAR:
231
 * @yr:  the year to format
232
 * @cur: a pointer to an allocated buffer
233
 *
234
 * Formats @yr in xsl:gYear format. Result is appended to @cur and
235
 * @cur is updated to point after the xsl:gYear.
236
 */
237
#define FORMAT_GYEAR(yr, cur)         \
238
350
  if (yr <= 0) {                 \
239
63
      *cur = '-';           \
240
63
      cur++;            \
241
63
  }              \
242
350
  {             \
243
350
      long year = (yr <= 0) ? -yr + 1 : yr;               \
244
350
      xmlChar tmp_buf[100], *tmp = tmp_buf;   \
245
350
      /* result is in reverse-order */      \
246
2.54k
      while (year > 0) {         \
247
2.19k
    *tmp = '0' + (xmlChar)(year % 10);    \
248
2.19k
    year /= 10;         \
249
2.19k
    tmp++;            \
250
2.19k
      }              \
251
350
      /* virtually adds leading zeros */      \
252
390
      while ((tmp - tmp_buf) < 4)       \
253
350
    *tmp++ = '0';         \
254
350
      /* restore the correct order */     \
255
2.58k
      while (tmp > tmp_buf) {       \
256
2.23k
    tmp--;            \
257
2.23k
    *cur = *tmp;          \
258
2.23k
    cur++;            \
259
2.23k
      }              \
260
350
  }
261
262
/**
263
 * PARSE_2_DIGITS:
264
 * @num:  the integer to fill in
265
 * @cur:  an #xmlChar *
266
 * @func: validation function for the number
267
 * @invalid: an integer
268
 *
269
 * Parses a 2-digits integer and updates @num with the value. @cur is
270
 * updated to point just after the integer.
271
 * In case of error, @invalid is set to %TRUE, values of @num and
272
 * @cur are undefined.
273
 */
274
#define PARSE_2_DIGITS(num, cur, func, invalid)     \
275
63.9k
  if ((cur[0] < '0') || (cur[0] > '9') ||     \
276
63.9k
      (cur[1] < '0') || (cur[1] > '9'))     \
277
63.9k
      invalid = 1;         \
278
63.9k
  else {             \
279
56.0k
      int val;            \
280
56.0k
      val = (cur[0] - '0') * 10 + (cur[1] - '0');   \
281
56.0k
      if (!func(val))          \
282
56.0k
          invalid = 2;         \
283
56.0k
      else            \
284
56.0k
          num = val;         \
285
56.0k
  }              \
286
63.9k
  cur += 2;
287
288
/**
289
 * FORMAT_2_DIGITS:
290
 * @num:  the integer to format
291
 * @cur: a pointer to an allocated buffer
292
 *
293
 * Formats a 2-digits integer. Result is appended to @cur and
294
 * @cur is updated to point after the integer.
295
 */
296
#define FORMAT_2_DIGITS(num, cur)       \
297
671
  *cur = '0' + ((num / 10) % 10);       \
298
671
  cur++;              \
299
671
  *cur = '0' + (num % 10);        \
300
671
  cur++;
301
302
/**
303
 * PARSE_FLOAT:
304
 * @num:  the double to fill in
305
 * @cur:  an #xmlChar *
306
 * @invalid: an integer
307
 *
308
 * Parses a float and updates @num with the value. @cur is
309
 * updated to point just after the float. The float must have a
310
 * 2-digits integer part and may or may not have a decimal part.
311
 * In case of error, @invalid is set to %TRUE, values of @num and
312
 * @cur are undefined.
313
 */
314
#define PARSE_FLOAT(num, cur, invalid)        \
315
4.45k
  PARSE_2_DIGITS(num, cur, VALID_ALWAYS, invalid); \
316
4.45k
  if (!invalid && (*cur == '.')) {     \
317
3.06k
      double mult = 1;                \
318
3.06k
      cur++;            \
319
3.06k
      if ((*cur < '0') || (*cur > '9'))     \
320
3.06k
    invalid = 1;         \
321
45.9k
      while ((*cur >= '0') && (*cur <= '9')) {   \
322
42.8k
    mult /= 10;         \
323
42.8k
    num += (*cur - '0') * mult;     \
324
42.8k
    cur++;            \
325
42.8k
      }              \
326
3.06k
  }
327
328
/**
329
 * _exsltDateParseGMonth:
330
 * @dt:  pointer to a date structure
331
 * @str: pointer to the string to analyze
332
 *
333
 * Parses a xs:gMonth without time zone and fills in the appropriate
334
 * field of the @dt structure. @str is updated to point just after the
335
 * xs:gMonth.
336
 *
337
 * Returns 0 or the error code
338
 */
339
static int
340
_exsltDateParseGMonth (exsltDateValPtr dt, const xmlChar **str)
341
10.1k
{
342
10.1k
    const xmlChar *cur = *str;
343
10.1k
    int ret = 0;
344
345
10.1k
    PARSE_2_DIGITS(dt->mon, cur, VALID_MONTH, ret);
346
10.1k
    if (ret != 0)
347
2.88k
  return ret;
348
349
7.29k
    *str = cur;
350
351
#ifdef DEBUG_EXSLT_DATE
352
    xsltGenericDebug(xsltGenericDebugContext,
353
         "Parsed month %02i\n", dt->mon);
354
#endif
355
356
7.29k
    return 0;
357
10.1k
}
358
359
/**
360
 * FORMAT_GMONTH:
361
 * @mon:  the month to format
362
 * @cur: a pointer to an allocated buffer
363
 *
364
 * Formats @mon in xsl:gMonth format. Result is appended to @cur and
365
 * @cur is updated to point after the xsl:gMonth.
366
 */
367
#define FORMAT_GMONTH(mon, cur)         \
368
338
  FORMAT_2_DIGITS(mon, cur)
369
370
/**
371
 * _exsltDateParseGDay:
372
 * @dt:  pointer to a date structure
373
 * @str: pointer to the string to analyze
374
 *
375
 * Parses a xs:gDay without time zone and fills in the appropriate
376
 * field of the @dt structure. @str is updated to point just after the
377
 * xs:gDay.
378
 *
379
 * Returns 0 or the error code
380
 */
381
static int
382
_exsltDateParseGDay (exsltDateValPtr dt, const xmlChar **str)
383
6.46k
{
384
6.46k
    const xmlChar *cur = *str;
385
6.46k
    int ret = 0;
386
387
6.46k
    PARSE_2_DIGITS(dt->day, cur, VALID_DAY, ret);
388
6.46k
    if (ret != 0)
389
861
  return ret;
390
391
5.60k
    *str = cur;
392
393
#ifdef DEBUG_EXSLT_DATE
394
    xsltGenericDebug(xsltGenericDebugContext,
395
         "Parsed day %02i\n", dt->day);
396
#endif
397
398
5.60k
    return 0;
399
6.46k
}
400
401
/**
402
 * FORMAT_GDAY:
403
 * @dt:  the #exsltDateVal to format
404
 * @cur: a pointer to an allocated buffer
405
 *
406
 * Formats @dt in xsl:gDay format. Result is appended to @cur and
407
 * @cur is updated to point after the xsl:gDay.
408
 */
409
#define FORMAT_GDAY(dt, cur)          \
410
309
  FORMAT_2_DIGITS(dt->day, cur)
411
412
/**
413
 * FORMAT_DATE:
414
 * @dt:  the #exsltDateVal to format
415
 * @cur: a pointer to an allocated buffer
416
 *
417
 * Formats @dt in xsl:date format. Result is appended to @cur and
418
 * @cur is updated to point after the xsl:date.
419
 */
420
#define FORMAT_DATE(dt, cur)          \
421
309
  FORMAT_GYEAR(dt->year, cur);        \
422
309
  *cur = '-';           \
423
309
  cur++;              \
424
309
  FORMAT_GMONTH(dt->mon, cur);       \
425
309
  *cur = '-';           \
426
309
  cur++;              \
427
309
  FORMAT_GDAY(dt, cur);
428
429
/**
430
 * _exsltDateParseTime:
431
 * @dt:  pointer to a date structure
432
 * @str: pointer to the string to analyze
433
 *
434
 * Parses a xs:time without time zone and fills in the appropriate
435
 * fields of the @dt structure. @str is updated to point just after the
436
 * xs:time.
437
 * In case of error, values of @dt fields are undefined.
438
 *
439
 * Returns 0 or the error code
440
 */
441
static int
442
_exsltDateParseTime (exsltDateValPtr dt, const xmlChar **str)
443
17.8k
{
444
17.8k
    const xmlChar *cur = *str;
445
17.8k
    unsigned int hour = 0; /* use temp var in case str is not xs:time */
446
17.8k
    int ret = 0;
447
448
17.8k
    PARSE_2_DIGITS(hour, cur, VALID_HOUR, ret);
449
17.8k
    if (ret != 0)
450
859
  return ret;
451
452
17.0k
    if (*cur != ':')
453
12.3k
  return 1;
454
4.67k
    cur++;
455
456
    /* the ':' insures this string is xs:time */
457
4.67k
    dt->hour = hour;
458
459
4.67k
    PARSE_2_DIGITS(dt->min, cur, VALID_MIN, ret);
460
4.67k
    if (ret != 0)
461
132
  return ret;
462
463
4.54k
    if (*cur != ':')
464
84
  return 1;
465
4.45k
    cur++;
466
467
4.45k
    PARSE_FLOAT(dt->sec, cur, ret);
468
4.45k
    if (ret != 0)
469
435
  return ret;
470
471
4.02k
    if (!VALID_TIME(dt))
472
14
  return 2;
473
474
4.01k
    *str = cur;
475
476
#ifdef DEBUG_EXSLT_DATE
477
    xsltGenericDebug(xsltGenericDebugContext,
478
         "Parsed time %02i:%02i:%02.f\n",
479
         dt->hour, dt->min, dt->sec);
480
#endif
481
482
4.01k
    return 0;
483
4.02k
}
484
485
/**
486
 * _exsltDateParseTimeZone:
487
 * @dt:  pointer to a date structure
488
 * @str: pointer to the string to analyze
489
 *
490
 * Parses a time zone without time zone and fills in the appropriate
491
 * field of the @dt structure. @str is updated to point just after the
492
 * time zone.
493
 *
494
 * Returns 0 or the error code
495
 */
496
static int
497
_exsltDateParseTimeZone (exsltDateValPtr dt, const xmlChar **str)
498
21.3k
{
499
21.3k
    const xmlChar *cur;
500
21.3k
    int ret = 0;
501
502
21.3k
    if (str == NULL)
503
0
  return -1;
504
21.3k
    cur = *str;
505
21.3k
    switch (*cur) {
506
1.57k
    case 0:
507
1.57k
  dt->tz_flag = 0;
508
1.57k
  dt->tzo = 0;
509
1.57k
  break;
510
511
55
    case 'Z':
512
55
  dt->tz_flag = 1;
513
55
  dt->tzo = 0;
514
55
  cur++;
515
55
  break;
516
517
127
    case '+':
518
19.3k
    case '-': {
519
19.3k
  int isneg = 0, tmp = 0;
520
19.3k
  isneg = (*cur == '-');
521
522
19.3k
  cur++;
523
524
19.3k
  PARSE_2_DIGITS(tmp, cur, VALID_HOUR, ret);
525
19.3k
  if (ret != 0)
526
3.59k
      return ret;
527
528
15.8k
  if (*cur != ':')
529
14.8k
      return 1;
530
954
  cur++;
531
532
954
  dt->tzo = tmp * 60;
533
534
954
  PARSE_2_DIGITS(tmp, cur, VALID_MIN, ret);
535
954
  if (ret != 0)
536
85
      return ret;
537
538
869
  dt->tzo += tmp;
539
869
  if (isneg)
540
862
      dt->tzo = - dt->tzo;
541
542
869
  if (!VALID_TZO(dt->tzo))
543
0
      return 2;
544
545
869
  break;
546
869
      }
547
869
    default:
548
354
  return 1;
549
21.3k
    }
550
551
2.50k
    *str = cur;
552
553
#ifdef DEBUG_EXSLT_DATE
554
    xsltGenericDebug(xsltGenericDebugContext,
555
         "Parsed time zone offset (%s) %i\n",
556
         dt->tz_flag ? "explicit" : "implicit", dt->tzo);
557
#endif
558
559
2.50k
    return 0;
560
21.3k
}
561
562
/**
563
 * FORMAT_TZ:
564
 * @tzo:  the timezone offset to format
565
 * @cur: a pointer to an allocated buffer
566
 *
567
 * Formats @tzo timezone. Result is appended to @cur and
568
 * @cur is updated to point after the timezone.
569
 */
570
#define FORMAT_TZ(tzo, cur)         \
571
224
  if (tzo == 0) {                 \
572
212
      *cur = 'Z';           \
573
212
      cur++;            \
574
212
  } else {           \
575
12
      int aTzo = (tzo < 0) ? - tzo : tzo;                 \
576
12
      int tzHh = aTzo / 60, tzMm = aTzo % 60;   \
577
12
      *cur = (tzo < 0) ? '-' : '+' ;      \
578
12
      cur++;            \
579
12
      FORMAT_2_DIGITS(tzHh, cur);        \
580
12
      *cur = ':';           \
581
12
      cur++;            \
582
12
      FORMAT_2_DIGITS(tzMm, cur);        \
583
12
  }
584
585
/****************************************************************
586
 *                *
587
 *  XML Schema Dates/Times Datatypes Handling   *
588
 *                *
589
 ****************************************************************/
590
591
/**
592
 * exsltDateCreateDate:
593
 * @type:       type to create
594
 *
595
 * Creates a new #exsltDateVal, uninitialized.
596
 *
597
 * Returns the #exsltDateValPtr
598
 */
599
static exsltDateValPtr
600
exsltDateCreateDate (exsltDateType type)
601
14.3k
{
602
14.3k
    exsltDateValPtr ret;
603
604
14.3k
    ret = (exsltDateValPtr) xmlMalloc(sizeof(exsltDateVal));
605
14.3k
    if (ret == NULL) {
606
0
  xsltGenericError(xsltGenericErrorContext,
607
0
       "exsltDateCreateDate: out of memory\n");
608
0
  return (NULL);
609
0
    }
610
14.3k
    memset (ret, 0, sizeof(exsltDateVal));
611
612
14.3k
    ret->mon = 1;
613
14.3k
    ret->day = 1;
614
615
14.3k
    if (type != EXSLT_UNKNOWN)
616
671
        ret->type = type;
617
618
14.3k
    return ret;
619
14.3k
}
620
621
/**
622
 * exsltDateFreeDate:
623
 * @date: an #exsltDateValPtr
624
 *
625
 * Frees up the @date
626
 */
627
static void
628
14.3k
exsltDateFreeDate (exsltDateValPtr date) {
629
14.3k
    if (date == NULL)
630
0
  return;
631
632
14.3k
    xmlFree(date);
633
14.3k
}
634
635
/**
636
 * exsltDateCreateDuration:
637
 *
638
 * Creates a new #exsltDateDurVal, uninitialized.
639
 *
640
 * Returns the #exsltDateDurValPtr
641
 */
642
static exsltDateDurValPtr
643
exsltDateCreateDuration (void)
644
5.35k
{
645
5.35k
    exsltDateDurValPtr ret;
646
647
5.35k
    ret = (exsltDateDurValPtr) xmlMalloc(sizeof(exsltDateDurVal));
648
5.35k
    if (ret == NULL) {
649
0
  xsltGenericError(xsltGenericErrorContext,
650
0
       "exsltDateCreateDuration: out of memory\n");
651
0
  return (NULL);
652
0
    }
653
5.35k
    memset (ret, 0, sizeof(exsltDateDurVal));
654
655
5.35k
    return ret;
656
5.35k
}
657
658
/**
659
 * exsltDateFreeDuration:
660
 * @date: an #exsltDateDurValPtr
661
 *
662
 * Frees up the @duration
663
 */
664
static void
665
5.35k
exsltDateFreeDuration (exsltDateDurValPtr duration) {
666
5.35k
    if (duration == NULL)
667
0
  return;
668
669
5.35k
    xmlFree(duration);
670
5.35k
}
671
672
/**
673
 * exsltDateCurrent:
674
 *
675
 * Returns the current date and time.
676
 */
677
static exsltDateValPtr
678
exsltDateCurrent (void)
679
318
{
680
318
    struct tm localTm, gmTm;
681
#if !defined(HAVE_GMTIME_R) && !defined(_WIN32)
682
    struct tm *tb = NULL;
683
#endif
684
318
    time_t secs;
685
318
    int local_s, gm_s;
686
318
    exsltDateValPtr ret;
687
318
    char *source_date_epoch;
688
318
    int override = 0;
689
690
318
    ret = exsltDateCreateDate(XS_DATETIME);
691
318
    if (ret == NULL)
692
0
        return NULL;
693
694
    /*
695
     * Allow the date and time to be set externally by an exported
696
     * environment variable to enable reproducible builds.
697
     */
698
318
    source_date_epoch = getenv("SOURCE_DATE_EPOCH");
699
318
    if (source_date_epoch) {
700
0
        errno = 0;
701
0
  secs = (time_t) strtol (source_date_epoch, NULL, 10);
702
0
  if (errno == 0) {
703
#ifdef _WIN32
704
      struct tm *gm = gmtime_s(&localTm, &secs) ? NULL : &localTm;
705
      if (gm != NULL)
706
          override = 1;
707
#elif HAVE_GMTIME_R
708
0
      if (gmtime_r(&secs, &localTm) != NULL)
709
0
          override = 1;
710
#else
711
      tb = gmtime(&secs);
712
      if (tb != NULL) {
713
          localTm = *tb;
714
    override = 1;
715
      }
716
#endif
717
0
        }
718
0
    }
719
720
318
    if (override == 0) {
721
    /* get current time */
722
318
  secs    = time(NULL);
723
724
#ifdef _WIN32
725
  localtime_s(&localTm, &secs);
726
#elif HAVE_LOCALTIME_R
727
318
  localtime_r(&secs, &localTm);
728
#else
729
  localTm = *localtime(&secs);
730
#endif
731
318
    }
732
733
    /* get real year, not years since 1900 */
734
318
    ret->year = localTm.tm_year + 1900;
735
736
318
    ret->mon  = localTm.tm_mon + 1;
737
318
    ret->day  = localTm.tm_mday;
738
318
    ret->hour = localTm.tm_hour;
739
318
    ret->min  = localTm.tm_min;
740
741
    /* floating point seconds */
742
318
    ret->sec  = (double) localTm.tm_sec;
743
744
    /* determine the time zone offset from local to gm time */
745
#ifdef _WIN32
746
    gmtime_s(&gmTm, &secs);
747
#elif HAVE_GMTIME_R
748
318
    gmtime_r(&secs, &gmTm);
749
#else
750
    tb = gmtime(&secs);
751
    if (tb == NULL)
752
        return NULL;
753
    gmTm = *tb;
754
#endif
755
318
    ret->tz_flag = 0;
756
#if 0
757
    ret->tzo = (((ret->day * 1440) +
758
                 (ret->hour * 60) +
759
                  ret->min) -
760
                ((gmTm.tm_mday * 1440) + (gmTm.tm_hour * 60) +
761
                  gmTm.tm_min));
762
#endif
763
318
    local_s = localTm.tm_hour * SECS_PER_HOUR +
764
318
        localTm.tm_min * SECS_PER_MIN +
765
318
        localTm.tm_sec;
766
767
318
    gm_s = gmTm.tm_hour * SECS_PER_HOUR +
768
318
        gmTm.tm_min * SECS_PER_MIN +
769
318
        gmTm.tm_sec;
770
771
318
    if (localTm.tm_year < gmTm.tm_year) {
772
0
  ret->tzo = -((SECS_PER_DAY - local_s) + gm_s)/60;
773
318
    } else if (localTm.tm_year > gmTm.tm_year) {
774
0
  ret->tzo = ((SECS_PER_DAY - gm_s) + local_s)/60;
775
318
    } else if (localTm.tm_mon < gmTm.tm_mon) {
776
0
  ret->tzo = -((SECS_PER_DAY - local_s) + gm_s)/60;
777
318
    } else if (localTm.tm_mon > gmTm.tm_mon) {
778
0
  ret->tzo = ((SECS_PER_DAY - gm_s) + local_s)/60;
779
318
    } else if (localTm.tm_mday < gmTm.tm_mday) {
780
0
  ret->tzo = -((SECS_PER_DAY - local_s) + gm_s)/60;
781
318
    } else if (localTm.tm_mday > gmTm.tm_mday) {
782
0
  ret->tzo = ((SECS_PER_DAY - gm_s) + local_s)/60;
783
318
    } else  {
784
318
  ret->tzo = (local_s - gm_s)/60;
785
318
    }
786
787
318
    return ret;
788
318
}
789
790
/**
791
 * exsltDateParse:
792
 * @dateTime:  string to analyze
793
 *
794
 * Parses a date/time string
795
 *
796
 * Returns a newly built #exsltDateValPtr of NULL in case of error
797
 */
798
static exsltDateValPtr
799
exsltDateParse (const xmlChar *dateTime)
800
13.7k
{
801
13.7k
    exsltDateValPtr dt;
802
13.7k
    int ret;
803
13.7k
    const xmlChar *cur = dateTime;
804
805
13.7k
#define RETURN_TYPE_IF_VALID(t)         \
806
24.1k
    if (IS_TZO_CHAR(*cur)) {         \
807
17.5k
  ret = _exsltDateParseTimeZone(dt, &cur);    \
808
17.5k
  if (ret == 0) {           \
809
1.02k
      if (*cur != 0)         \
810
1.02k
    goto error;         \
811
1.02k
      dt->type = t;         \
812
835
      return dt;           \
813
1.02k
  }              \
814
17.5k
    }
815
816
13.7k
    if (dateTime == NULL)
817
0
  return NULL;
818
819
13.7k
    if ((*cur != '-') && (*cur < '0') && (*cur > '9'))
820
0
  return NULL;
821
822
13.7k
    dt = exsltDateCreateDate(EXSLT_UNKNOWN);
823
13.7k
    if (dt == NULL)
824
0
  return NULL;
825
826
13.7k
    if ((cur[0] == '-') && (cur[1] == '-')) {
827
  /*
828
   * It's an incomplete date (xs:gMonthDay, xs:gMonth or
829
   * xs:gDay)
830
   */
831
235
  cur += 2;
832
833
  /* is it an xs:gDay? */
834
235
  if (*cur == '-') {
835
103
    ++cur;
836
103
      ret = _exsltDateParseGDay(dt, &cur);
837
103
      if (ret != 0)
838
52
    goto error;
839
840
51
      RETURN_TYPE_IF_VALID(XS_GDAY);
841
842
36
      goto error;
843
51
  }
844
845
  /*
846
   * it should be an xs:gMonthDay or xs:gMonth
847
   */
848
132
  ret = _exsltDateParseGMonth(dt, &cur);
849
132
  if (ret != 0)
850
67
      goto error;
851
852
65
  if (*cur != '-')
853
4
      goto error;
854
61
  cur++;
855
856
  /* is it an xs:gMonth? */
857
61
  if (*cur == '-') {
858
31
      cur++;
859
31
      RETURN_TYPE_IF_VALID(XS_GMONTH);
860
21
      goto error;
861
31
  }
862
863
  /* it should be an xs:gMonthDay */
864
30
  ret = _exsltDateParseGDay(dt, &cur);
865
30
  if (ret != 0)
866
13
      goto error;
867
868
17
  RETURN_TYPE_IF_VALID(XS_GMONTHDAY);
869
870
13
  goto error;
871
17
    }
872
873
    /*
874
     * It's a right-truncated date or an xs:time.
875
     * Try to parse an xs:time then fallback on right-truncated dates.
876
     */
877
13.4k
    if ((*cur >= '0') && (*cur <= '9')) {
878
12.7k
  ret = _exsltDateParseTime(dt, &cur);
879
12.7k
  if (ret == 0) {
880
      /* it's an xs:time */
881
195
      RETURN_TYPE_IF_VALID(XS_TIME);
882
65
  }
883
12.7k
    }
884
885
    /* fallback on date parsing */
886
13.3k
    cur = dateTime;
887
888
13.3k
    ret = _exsltDateParseGYear(dt, &cur);
889
13.3k
    if (ret != 0)
890
2.22k
  goto error;
891
892
    /* is it an xs:gYear? */
893
11.1k
    RETURN_TYPE_IF_VALID(XS_GYEAR);
894
895
10.6k
    if (*cur != '-')
896
599
  goto error;
897
10.0k
    cur++;
898
899
10.0k
    ret = _exsltDateParseGMonth(dt, &cur);
900
10.0k
    if (ret != 0)
901
2.82k
  goto error;
902
903
    /* is it an xs:gYearMonth? */
904
7.22k
    RETURN_TYPE_IF_VALID(XS_GYEARMONTH);
905
906
6.93k
    if (*cur != '-')
907
605
  goto error;
908
6.33k
    cur++;
909
910
6.33k
    ret = _exsltDateParseGDay(dt, &cur);
911
6.33k
    if ((ret != 0) || !VALID_DATE(dt))
912
805
  goto error;
913
914
    /* is it an xs:date? */
915
5.52k
    RETURN_TYPE_IF_VALID(XS_DATE);
916
917
5.43k
    if (*cur != 'T')
918
364
  goto error;
919
5.06k
    cur++;
920
921
    /* it should be an xs:dateTime */
922
5.06k
    ret = _exsltDateParseTime(dt, &cur);
923
5.06k
    if (ret != 0)
924
1.25k
  goto error;
925
926
3.81k
    ret = _exsltDateParseTimeZone(dt, &cur);
927
3.81k
    if ((ret != 0) || (*cur != 0) || !VALID_DATETIME(dt))
928
2.91k
  goto error;
929
930
896
    dt->type = XS_DATETIME;
931
932
896
    return dt;
933
934
11.9k
error:
935
11.9k
    if (dt != NULL)
936
11.9k
  exsltDateFreeDate(dt);
937
11.9k
    return NULL;
938
3.81k
}
939
940
/**
941
 * exsltDateParseDuration:
942
 * @duration:  string to analyze
943
 *
944
 * Parses a duration string
945
 *
946
 * Returns a newly built #exsltDateDurValPtr of NULL in case of error
947
 */
948
static exsltDateDurValPtr
949
exsltDateParseDuration (const xmlChar *duration)
950
3.73k
{
951
3.73k
    const xmlChar  *cur = duration;
952
3.73k
    exsltDateDurValPtr dur;
953
3.73k
    int isneg = 0;
954
3.73k
    unsigned int seq = 0;
955
3.73k
    long days, secs = 0;
956
3.73k
    double sec_frac = 0.0;
957
958
3.73k
    if (duration == NULL)
959
0
  return NULL;
960
961
3.73k
    if (*cur == '-') {
962
2.85k
        isneg = 1;
963
2.85k
        cur++;
964
2.85k
    }
965
966
    /* duration must start with 'P' (after sign) */
967
3.73k
    if (*cur++ != 'P')
968
280
  return NULL;
969
970
3.45k
    if (*cur == 0)
971
16
  return NULL;
972
973
3.43k
    dur = exsltDateCreateDuration();
974
3.43k
    if (dur == NULL)
975
0
  return NULL;
976
977
17.9k
    while (*cur != 0) {
978
16.0k
        long           num = 0;
979
16.0k
        size_t         has_digits = 0;
980
16.0k
        int            has_frac = 0;
981
16.0k
        const xmlChar  desig[] = {'Y', 'M', 'D', 'H', 'M', 'S'};
982
983
        /* input string should be empty or invalid date/time item */
984
16.0k
        if (seq >= sizeof(desig))
985
594
            goto error;
986
987
        /* T designator must be present for time items */
988
15.4k
        if (*cur == 'T') {
989
2.64k
            if (seq > 3)
990
1
                goto error;
991
2.64k
            cur++;
992
2.64k
            seq = 3;
993
12.8k
        } else if (seq == 3)
994
74
            goto error;
995
996
        /* Parse integral part. */
997
65.0k
        while (*cur >= '0' && *cur <= '9') {
998
49.6k
            long digit = *cur - '0';
999
1000
49.6k
            if (num > LONG_MAX / 10)
1001
21
                goto error;
1002
49.6k
            num *= 10;
1003
49.6k
            if (num > LONG_MAX - digit)
1004
0
                goto error;
1005
49.6k
            num += digit;
1006
1007
49.6k
            has_digits = 1;
1008
49.6k
            cur++;
1009
49.6k
        }
1010
1011
15.3k
        if (*cur == '.') {
1012
            /* Parse fractional part. */
1013
301
            double mult = 1.0;
1014
301
            cur++;
1015
301
            has_frac = 1;
1016
14.3k
            while (*cur >= '0' && *cur <= '9') {
1017
14.0k
                mult /= 10.0;
1018
14.0k
                sec_frac += (*cur - '0') * mult;
1019
14.0k
                has_digits = 1;
1020
14.0k
                cur++;
1021
14.0k
            }
1022
301
        }
1023
1024
17.4k
        while (*cur != desig[seq]) {
1025
2.87k
            seq++;
1026
            /* No T designator or invalid char. */
1027
2.87k
            if (seq == 3 || seq == sizeof(desig))
1028
765
                goto error;
1029
2.87k
        }
1030
14.6k
        cur++;
1031
1032
14.6k
        if (!has_digits || (has_frac && (seq != 5)))
1033
77
            goto error;
1034
1035
14.5k
        switch (seq) {
1036
2.80k
            case 0:
1037
                /* Year */
1038
2.80k
                if (num > LONG_MAX / 12)
1039
5
                    goto error;
1040
2.79k
                dur->mon = num * 12;
1041
2.79k
                break;
1042
2.62k
            case 1:
1043
                /* Month */
1044
2.62k
                if (dur->mon > LONG_MAX - num)
1045
0
                    goto error;
1046
2.62k
                dur->mon += num;
1047
2.62k
                break;
1048
2.61k
            case 2:
1049
                /* Day */
1050
2.61k
                dur->day = num;
1051
2.61k
                break;
1052
2.21k
            case 3:
1053
                /* Hour */
1054
2.21k
                days = num / HOURS_PER_DAY;
1055
2.21k
                if (dur->day > LONG_MAX - days)
1056
0
                    goto error;
1057
2.21k
                dur->day += days;
1058
2.21k
                secs = (num % HOURS_PER_DAY) * SECS_PER_HOUR;
1059
2.21k
                break;
1060
2.00k
            case 4:
1061
                /* Minute */
1062
2.00k
                days = num / MINS_PER_DAY;
1063
2.00k
                if (dur->day > LONG_MAX - days)
1064
0
                    goto error;
1065
2.00k
                dur->day += days;
1066
2.00k
                secs += (num % MINS_PER_DAY) * SECS_PER_MIN;
1067
2.00k
                break;
1068
2.26k
            case 5:
1069
                /* Second */
1070
2.26k
                days = num / SECS_PER_DAY;
1071
2.26k
                if (dur->day > LONG_MAX - days)
1072
0
                    goto error;
1073
2.26k
                dur->day += days;
1074
2.26k
                secs += num % SECS_PER_DAY;
1075
2.26k
                break;
1076
14.5k
        }
1077
1078
14.5k
        seq++;
1079
14.5k
    }
1080
1081
1.90k
    days = secs / SECS_PER_DAY;
1082
1.90k
    if (dur->day > LONG_MAX - days)
1083
0
        goto error;
1084
1.90k
    dur->day += days;
1085
1.90k
    dur->sec = (secs % SECS_PER_DAY) + sec_frac;
1086
1087
1.90k
    if (isneg) {
1088
1.39k
        dur->mon = -dur->mon;
1089
1.39k
        dur->day = -dur->day;
1090
1.39k
        if (dur->sec != 0.0) {
1091
1.27k
            dur->sec = SECS_PER_DAY - dur->sec;
1092
1.27k
            dur->day -= 1;
1093
1.27k
        }
1094
1.39k
    }
1095
1096
#ifdef DEBUG_EXSLT_DATE
1097
    xsltGenericDebug(xsltGenericDebugContext,
1098
         "Parsed duration %f\n", dur->sec);
1099
#endif
1100
1101
1.90k
    return dur;
1102
1103
1.53k
error:
1104
1.53k
    if (dur != NULL)
1105
1.53k
  exsltDateFreeDuration(dur);
1106
1.53k
    return NULL;
1107
1.90k
}
1108
1109
static void
1110
1.31k
exsltFormatLong(xmlChar **cur, xmlChar *end, long num) {
1111
1.31k
    xmlChar buf[20];
1112
1.31k
    int i = 0;
1113
1114
3.01k
    while (i < 20) {
1115
3.01k
        buf[i++] = '0' + num % 10;
1116
3.01k
        num /= 10;
1117
3.01k
        if (num == 0)
1118
1.31k
            break;
1119
3.01k
    }
1120
1121
4.32k
    while (i > 0) {
1122
3.01k
        if (*cur < end)
1123
3.01k
            *(*cur)++ = buf[--i];
1124
3.01k
    }
1125
1.31k
}
1126
1127
static void
1128
515
exsltFormatNanoseconds(xmlChar **cur, xmlChar *end, long nsecs) {
1129
515
    long p10, digit;
1130
1131
515
    if (nsecs > 0) {
1132
75
        if (*cur < end)
1133
75
            *(*cur)++ = '.';
1134
75
        p10 = 100000000;
1135
347
        while (nsecs > 0) {
1136
272
            digit = nsecs / p10;
1137
272
            if (*cur < end)
1138
272
                *(*cur)++ = '0' + digit;
1139
272
            nsecs -= digit * p10;
1140
272
            p10 /= 10;
1141
272
        }
1142
75
    }
1143
515
}
1144
1145
/**
1146
 * exsltDateFormatDuration:
1147
 * @dur: an #exsltDateDurValPtr
1148
 *
1149
 * Formats the duration.
1150
 *
1151
 * Returns a newly allocated string, or NULL in case of error
1152
 */
1153
static xmlChar *
1154
exsltDateFormatDuration (const exsltDateDurValPtr dur)
1155
370
{
1156
370
    xmlChar buf[100], *cur = buf, *end = buf + 99;
1157
370
    double secs, tmp;
1158
370
    long days, months, intSecs, nsecs;
1159
1160
370
    if (dur == NULL)
1161
0
  return NULL;
1162
1163
    /* quick and dirty check */
1164
370
    if ((dur->sec == 0.0) && (dur->day == 0) && (dur->mon == 0))
1165
9
        return xmlStrdup((xmlChar*)"P0D");
1166
1167
361
    secs   = dur->sec;
1168
361
    days   = dur->day;
1169
361
    months = dur->mon;
1170
1171
361
    *cur = '\0';
1172
361
    if (days < 0) {
1173
147
        if (secs != 0.0) {
1174
146
            secs = SECS_PER_DAY - secs;
1175
146
            days += 1;
1176
146
        }
1177
147
        days = -days;
1178
147
        *cur = '-';
1179
147
    }
1180
361
    if (months < 0) {
1181
165
        months = -months;
1182
165
        *cur = '-';
1183
165
    }
1184
361
    if (*cur == '-')
1185
178
  cur++;
1186
1187
361
    *cur++ = 'P';
1188
1189
361
    if (months >= 12) {
1190
219
        long years = months / 12;
1191
1192
219
        months -= years * 12;
1193
219
        exsltFormatLong(&cur, end, years);
1194
219
        if (cur < end)
1195
219
            *cur++ = 'Y';
1196
219
    }
1197
1198
361
    if (months != 0) {
1199
158
        exsltFormatLong(&cur, end, months);
1200
158
        if (cur < end)
1201
158
            *cur++ = 'M';
1202
158
    }
1203
1204
361
    if (days != 0) {
1205
242
        exsltFormatLong(&cur, end, days);
1206
242
        if (cur < end)
1207
242
            *cur++ = 'D';
1208
242
    }
1209
1210
361
    tmp = floor(secs);
1211
361
    intSecs = (long) tmp;
1212
    /* Round to nearest to avoid issues with floating point precision */
1213
361
    nsecs = (long) floor((secs - tmp) * 1000000000 + 0.5);
1214
361
    if (nsecs >= 1000000000) {
1215
0
        nsecs -= 1000000000;
1216
0
        intSecs += 1;
1217
0
    }
1218
1219
361
    if ((intSecs > 0) || (nsecs > 0)) {
1220
267
        if (cur < end)
1221
267
            *cur++ = 'T';
1222
1223
267
        if (intSecs >= SECS_PER_HOUR) {
1224
222
            long hours = intSecs / SECS_PER_HOUR;
1225
1226
222
            intSecs -= hours * SECS_PER_HOUR;
1227
222
            exsltFormatLong(&cur, end, hours);
1228
222
            if (cur < end)
1229
222
                *cur++ = 'H';
1230
222
        }
1231
1232
267
        if (intSecs >= SECS_PER_MIN) {
1233
223
            long mins = intSecs / SECS_PER_MIN;
1234
1235
223
            intSecs -= mins * SECS_PER_MIN;
1236
223
            exsltFormatLong(&cur, end, mins);
1237
223
            if (cur < end)
1238
223
                *cur++ = 'M';
1239
223
        }
1240
1241
267
        if ((intSecs > 0) || (nsecs > 0)) {
1242
252
            exsltFormatLong(&cur, end, intSecs);
1243
252
            exsltFormatNanoseconds(&cur, end, nsecs);
1244
252
            if (cur < end)
1245
252
                *cur++ = 'S';
1246
252
        }
1247
267
    }
1248
1249
361
    *cur = 0;
1250
1251
361
    return xmlStrdup(buf);
1252
370
}
1253
1254
static void
1255
789
exsltFormatTwoDigits(xmlChar **cur, xmlChar *end, int num) {
1256
789
    if (num < 0 || num >= 100)
1257
0
        return;
1258
789
    if (*cur < end)
1259
789
        *(*cur)++ = '0' + num / 10;
1260
789
    if (*cur < end)
1261
789
        *(*cur)++ = '0' + num % 10;
1262
789
}
1263
1264
static void
1265
263
exsltFormatTime(xmlChar **cur, xmlChar *end, exsltDateValPtr dt) {
1266
263
    double tmp;
1267
263
    long intSecs, nsecs;
1268
1269
263
    exsltFormatTwoDigits(cur, end, dt->hour);
1270
263
    if (*cur < end)
1271
263
        *(*cur)++ = ':';
1272
1273
263
    exsltFormatTwoDigits(cur, end, dt->min);
1274
263
    if (*cur < end)
1275
263
        *(*cur)++ = ':';
1276
1277
263
    tmp = floor(dt->sec);
1278
263
    intSecs = (long) tmp;
1279
    /*
1280
     * Round to nearest to avoid issues with floating point precision,
1281
     * but don't carry over so seconds stay below 60.
1282
     */
1283
263
    nsecs = (long) floor((dt->sec - tmp) * 1000000000 + 0.5);
1284
263
    if (nsecs > 999999999)
1285
1
        nsecs = 999999999;
1286
263
    exsltFormatTwoDigits(cur, end, intSecs);
1287
263
    exsltFormatNanoseconds(cur, end, nsecs);
1288
263
}
1289
1290
/**
1291
 * exsltDateFormatDateTime:
1292
 * @dt: an #exsltDateValPtr
1293
 *
1294
 * Formats @dt in xs:dateTime format.
1295
 *
1296
 * Returns a newly allocated string, or NULL in case of error
1297
 */
1298
static xmlChar *
1299
exsltDateFormatDateTime (const exsltDateValPtr dt)
1300
217
{
1301
217
    xmlChar buf[100], *cur = buf, *end = buf + 99;
1302
1303
217
    if ((dt == NULL) || !VALID_DATETIME(dt))
1304
0
  return NULL;
1305
1306
217
    FORMAT_DATE(dt, cur);
1307
217
    *cur = 'T';
1308
217
    cur++;
1309
217
    exsltFormatTime(&cur, end, dt);
1310
217
    FORMAT_TZ(dt->tzo, cur);
1311
217
    *cur = 0;
1312
1313
217
    return xmlStrdup(buf);
1314
217
}
1315
1316
/**
1317
 * exsltDateFormatDate:
1318
 * @dt: an #exsltDateValPtr
1319
 *
1320
 * Formats @dt in xs:date format.
1321
 *
1322
 * Returns a newly allocated string, or NULL in case of error
1323
 */
1324
static xmlChar *
1325
exsltDateFormatDate (const exsltDateValPtr dt)
1326
92
{
1327
92
    xmlChar buf[100], *cur = buf;
1328
1329
92
    if ((dt == NULL) || !VALID_DATETIME(dt))
1330
0
  return NULL;
1331
1332
92
    FORMAT_DATE(dt, cur);
1333
92
    if (dt->tz_flag || (dt->tzo != 0)) {
1334
5
  FORMAT_TZ(dt->tzo, cur);
1335
5
    }
1336
92
    *cur = 0;
1337
1338
92
    return xmlStrdup(buf);
1339
92
}
1340
1341
/**
1342
 * exsltDateFormatTime:
1343
 * @dt: an #exsltDateValPtr
1344
 *
1345
 * Formats @dt in xs:time format.
1346
 *
1347
 * Returns a newly allocated string, or NULL in case of error
1348
 */
1349
static xmlChar *
1350
exsltDateFormatTime (const exsltDateValPtr dt)
1351
46
{
1352
46
    xmlChar buf[100], *cur = buf, *end = buf + 99;
1353
1354
46
    if ((dt == NULL) || !VALID_TIME(dt))
1355
0
  return NULL;
1356
1357
46
    exsltFormatTime(&cur, end, dt);
1358
46
    if (dt->tz_flag || (dt->tzo != 0)) {
1359
0
  FORMAT_TZ(dt->tzo, cur);
1360
0
    }
1361
46
    *cur = 0;
1362
1363
46
    return xmlStrdup(buf);
1364
46
}
1365
1366
/**
1367
 * exsltDateFormat:
1368
 * @dt: an #exsltDateValPtr
1369
 *
1370
 * Formats @dt in the proper format.
1371
 * Note: xs:gmonth and xs:gday are not formatted as there are no
1372
 * routines that output them.
1373
 *
1374
 * Returns a newly allocated string, or NULL in case of error
1375
 */
1376
static xmlChar *
1377
exsltDateFormat (const exsltDateValPtr dt)
1378
269
{
1379
1380
269
    if (dt == NULL)
1381
0
  return NULL;
1382
1383
269
    switch (dt->type) {
1384
199
    case XS_DATETIME:
1385
199
        return exsltDateFormatDateTime(dt);
1386
29
    case XS_DATE:
1387
29
        return exsltDateFormatDate(dt);
1388
0
    case XS_TIME:
1389
0
        return exsltDateFormatTime(dt);
1390
41
    default:
1391
41
        break;
1392
269
    }
1393
1394
41
    if (dt->type & XS_GYEAR) {
1395
41
        xmlChar buf[100], *cur = buf;
1396
1397
41
        FORMAT_GYEAR(dt->year, cur);
1398
41
        if (dt->type == XS_GYEARMONTH) {
1399
29
      *cur = '-';
1400
29
      cur++;
1401
29
      FORMAT_GMONTH(dt->mon, cur);
1402
29
        }
1403
1404
41
        if (dt->tz_flag || (dt->tzo != 0)) {
1405
2
      FORMAT_TZ(dt->tzo, cur);
1406
2
        }
1407
41
        *cur = 0;
1408
41
        return xmlStrdup(buf);
1409
41
    }
1410
1411
0
    return NULL;
1412
41
}
1413
1414
/**
1415
 * _exsltDateCastYMToDays:
1416
 * @dt: an #exsltDateValPtr
1417
 *
1418
 * Convert mon and year of @dt to total number of days. Take the
1419
 * number of years since (or before) 1 AD and add the number of leap
1420
 * years. This is a function  because negative
1421
 * years must be handled a little differently.
1422
 *
1423
 * Returns number of days.
1424
 */
1425
static long
1426
_exsltDateCastYMToDays (const exsltDateValPtr dt)
1427
226
{
1428
226
    long ret;
1429
1430
226
    if (dt->year <= 0)
1431
2
        ret = ((dt->year-1) * 365) +
1432
2
              (((dt->year)/4)-((dt->year)/100)+
1433
2
               ((dt->year)/400)) +
1434
2
              DAY_IN_YEAR(0, dt->mon, dt->year) - 1;
1435
224
    else
1436
224
        ret = ((dt->year-1) * 365) +
1437
224
              (((dt->year-1)/4)-((dt->year-1)/100)+
1438
224
               ((dt->year-1)/400)) +
1439
224
              DAY_IN_YEAR(0, dt->mon, dt->year);
1440
1441
226
    return ret;
1442
226
}
1443
1444
/**
1445
 * TIME_TO_NUMBER:
1446
 * @dt:  an #exsltDateValPtr
1447
 *
1448
 * Calculates the number of seconds in the time portion of @dt.
1449
 *
1450
 * Returns seconds.
1451
 */
1452
#define TIME_TO_NUMBER(dt)                              \
1453
226
    ((double)((dt->hour * SECS_PER_HOUR) +   \
1454
226
              (dt->min * SECS_PER_MIN)) + dt->sec)
1455
1456
/**
1457
 * _exsltDateTruncateDate:
1458
 * @dt: an #exsltDateValPtr
1459
 * @type: dateTime type to set to
1460
 *
1461
 * Set @dt to truncated @type.
1462
 *
1463
 * Returns 0 success, non-zero otherwise.
1464
 */
1465
static int
1466
_exsltDateTruncateDate (exsltDateValPtr dt, exsltDateType type)
1467
90
{
1468
90
    if (dt == NULL)
1469
0
        return 1;
1470
1471
90
    if ((type & XS_TIME) != XS_TIME) {
1472
90
        dt->hour = 0;
1473
90
        dt->min  = 0;
1474
90
        dt->sec  = 0.0;
1475
90
    }
1476
1477
90
    if ((type & XS_GDAY) != XS_GDAY)
1478
82
        dt->day = 1;
1479
1480
90
    if ((type & XS_GMONTH) != XS_GMONTH)
1481
63
        dt->mon = 1;
1482
1483
90
    if ((type & XS_GYEAR) != XS_GYEAR)
1484
0
        dt->year = 0;
1485
1486
90
    dt->type = type;
1487
1488
90
    return 0;
1489
90
}
1490
1491
/**
1492
 * _exsltDayInWeek:
1493
 * @yday: year day (1-366)
1494
 * @yr: year
1495
 *
1496
 * Determine the day-in-week from @yday and @yr. 0001-01-01 was
1497
 * a Monday so all other days are calculated from there. Take the
1498
 * number of years since (or before) add the number of leap years and
1499
 * the day-in-year and mod by 7. This is a function  because negative
1500
 * years must be handled a little differently.
1501
 *
1502
 * Returns day in week (Sunday = 0).
1503
 */
1504
static long
1505
_exsltDateDayInWeek(long yday, long yr)
1506
203
{
1507
203
    long ret;
1508
1509
203
    if (yr <= 0) {
1510
        /* Compute modulus twice to avoid integer overflow */
1511
1
        ret = ((yr%7-2 + ((yr/4)-(yr/100)+(yr/400)) + yday) % 7);
1512
1
        if (ret < 0)
1513
1
            ret += 7;
1514
1
    } else
1515
202
        ret = (((yr%7-1) + (((yr-1)/4)-((yr-1)/100)+((yr-1)/400)) + yday) % 7);
1516
1517
203
    return ret;
1518
203
}
1519
1520
/**
1521
 * _exsltDateAdd:
1522
 * @dt: an #exsltDateValPtr
1523
 * @dur: an #exsltDateDurValPtr
1524
 *
1525
 * Compute a new date/time from @dt and @dur. This function assumes @dt
1526
 * is either #XS_DATETIME, #XS_DATE, #XS_GYEARMONTH, or #XS_GYEAR.
1527
 *
1528
 * Returns date/time pointer or NULL.
1529
 */
1530
static exsltDateValPtr
1531
_exsltDateAdd (exsltDateValPtr dt, exsltDateDurValPtr dur)
1532
269
{
1533
269
    exsltDateValPtr ret;
1534
269
    long carry, temp;
1535
269
    double sum;
1536
1537
269
    if ((dt == NULL) || (dur == NULL))
1538
0
        return NULL;
1539
1540
269
    ret = exsltDateCreateDate(dt->type);
1541
269
    if (ret == NULL)
1542
0
        return NULL;
1543
1544
    /*
1545
     * Note that temporary values may need more bits than the values in
1546
     * bit field.
1547
     */
1548
1549
    /* month */
1550
269
    temp  = dt->mon + dur->mon % 12;
1551
269
    carry = dur->mon / 12;
1552
269
    if (temp < 1) {
1553
98
        temp  += 12;
1554
98
        carry -= 1;
1555
98
    }
1556
171
    else if (temp > 12) {
1557
0
        temp  -= 12;
1558
0
        carry += 1;
1559
0
    }
1560
269
    ret->mon = temp;
1561
1562
    /*
1563
     * year (may be modified later)
1564
     *
1565
     * Add epochs from dur->day now to avoid overflow later and to speed up
1566
     * pathological cases.
1567
     */
1568
269
    carry += (dur->day / DAYS_PER_EPOCH) * YEARS_PER_EPOCH;
1569
269
    if ((carry > 0 && dt->year > YEAR_MAX - carry) ||
1570
269
        (carry < 0 && dt->year < YEAR_MIN - carry)) {
1571
        /* Overflow */
1572
0
        exsltDateFreeDate(ret);
1573
0
        return NULL;
1574
0
    }
1575
269
    ret->year = dt->year + carry;
1576
1577
    /* time zone */
1578
269
    ret->tzo     = dt->tzo;
1579
269
    ret->tz_flag = dt->tz_flag;
1580
1581
    /* seconds */
1582
269
    sum    = dt->sec + dur->sec;
1583
269
    ret->sec = fmod(sum, 60.0);
1584
269
    carry  = (long)(sum / 60.0);
1585
1586
    /* minute */
1587
269
    temp  = dt->min + carry % 60;
1588
269
    carry = carry / 60;
1589
269
    if (temp >= 60) {
1590
0
        temp  -= 60;
1591
0
        carry += 1;
1592
0
    }
1593
269
    ret->min = temp;
1594
1595
    /* hours */
1596
269
    temp  = dt->hour + carry % 24;
1597
269
    carry = carry / 24;
1598
269
    if (temp >= 24) {
1599
94
        temp  -= 24;
1600
94
        carry += 1;
1601
94
    }
1602
269
    ret->hour = temp;
1603
1604
    /* days */
1605
269
    if (dt->day > MAX_DAYINMONTH(ret->year, ret->mon))
1606
1
        temp = MAX_DAYINMONTH(ret->year, ret->mon);
1607
268
    else if (dt->day < 1)
1608
0
        temp = 1;
1609
268
    else
1610
268
        temp = dt->day;
1611
1612
269
    temp += dur->day % DAYS_PER_EPOCH + carry;
1613
1614
103k
    while (1) {
1615
103k
        if (temp < 1) {
1616
103k
            if (ret->mon > 1) {
1617
94.4k
                ret->mon -= 1;
1618
94.4k
            }
1619
8.64k
            else {
1620
8.64k
                if (ret->year == YEAR_MIN) {
1621
0
                    exsltDateFreeDate(ret);
1622
0
                    return NULL;
1623
0
                }
1624
8.64k
                ret->mon   = 12;
1625
8.64k
                ret->year -= 1;
1626
8.64k
            }
1627
103k
            temp += MAX_DAYINMONTH(ret->year, ret->mon);
1628
103k
        } else if (temp > (long)MAX_DAYINMONTH(ret->year, ret->mon)) {
1629
0
            temp -= MAX_DAYINMONTH(ret->year, ret->mon);
1630
0
            if (ret->mon < 12) {
1631
0
                ret->mon += 1;
1632
0
            }
1633
0
            else {
1634
0
                if (ret->year == YEAR_MAX) {
1635
0
                    exsltDateFreeDate(ret);
1636
0
                    return NULL;
1637
0
                }
1638
0
                ret->mon   = 1;
1639
0
                ret->year += 1;
1640
0
            }
1641
0
        } else
1642
269
            break;
1643
103k
    }
1644
1645
269
    ret->day = temp;
1646
1647
    /*
1648
     * adjust the date/time type to the date values
1649
     */
1650
269
    if (ret->type != XS_DATETIME) {
1651
167
        if ((ret->hour) || (ret->min) || (ret->sec))
1652
97
            ret->type = XS_DATETIME;
1653
70
        else if (ret->type != XS_DATE) {
1654
65
            if (ret->day != 1)
1655
24
                ret->type = XS_DATE;
1656
41
            else if ((ret->type != XS_GYEARMONTH) && (ret->mon != 1))
1657
4
                ret->type = XS_GYEARMONTH;
1658
65
        }
1659
167
    }
1660
1661
269
    return ret;
1662
269
}
1663
1664
/**
1665
 * _exsltDateDifference:
1666
 * @x: an #exsltDateValPtr
1667
 * @y: an #exsltDateValPtr
1668
 * @flag: force difference in days
1669
 *
1670
 * Calculate the difference between @x and @y as a duration
1671
 * (i.e. y - x). If the @flag is set then even if the least specific
1672
 * format of @x or @y is xs:gYear or xs:gYearMonth.
1673
 *
1674
 * Returns a duration pointer or NULL.
1675
 */
1676
static exsltDateDurValPtr
1677
_exsltDateDifference (exsltDateValPtr x, exsltDateValPtr y, int flag)
1678
192
{
1679
192
    exsltDateDurValPtr ret;
1680
1681
192
    if ((x == NULL) || (y == NULL))
1682
0
        return NULL;
1683
1684
192
    if (((x->type < XS_GYEAR) || (x->type > XS_DATETIME)) ||
1685
192
        ((y->type < XS_GYEAR) || (y->type > XS_DATETIME)))
1686
0
        return NULL;
1687
1688
    /*
1689
     * the operand with the most specific format must be converted to
1690
     * the same type as the operand with the least specific format.
1691
     */
1692
192
    if (x->type != y->type) {
1693
90
        if (x->type < y->type) {
1694
30
            _exsltDateTruncateDate(y, x->type);
1695
60
        } else {
1696
60
            _exsltDateTruncateDate(x, y->type);
1697
60
        }
1698
90
    }
1699
1700
192
    ret = exsltDateCreateDuration();
1701
192
    if (ret == NULL)
1702
0
        return NULL;
1703
1704
192
    if (((x->type == XS_GYEAR) || (x->type == XS_GYEARMONTH)) && (!flag)) {
1705
        /* compute the difference in months */
1706
74
        if ((x->year >= LONG_MAX / 24) || (x->year <= LONG_MIN / 24) ||
1707
74
            (y->year >= LONG_MAX / 24) || (y->year <= LONG_MIN / 24)) {
1708
            /* Possible overflow. */
1709
0
            exsltDateFreeDuration(ret);
1710
0
            return NULL;
1711
0
        }
1712
74
        ret->mon = (y->year - x->year) * 12 + (y->mon - x->mon);
1713
118
    } else {
1714
118
        long carry;
1715
1716
118
        if ((x->year > LONG_MAX / 731) || (x->year < LONG_MIN / 731) ||
1717
118
            (y->year > LONG_MAX / 731) || (y->year < LONG_MIN / 731)) {
1718
            /* Possible overflow. */
1719
5
            exsltDateFreeDuration(ret);
1720
5
            return NULL;
1721
5
        }
1722
1723
113
        ret->sec  = TIME_TO_NUMBER(y) - TIME_TO_NUMBER(x);
1724
113
        ret->sec += (x->tzo - y->tzo) * SECS_PER_MIN;
1725
113
        carry    = (long)floor(ret->sec / SECS_PER_DAY);
1726
113
        ret->sec  = ret->sec - carry * SECS_PER_DAY;
1727
1728
113
        ret->day  = _exsltDateCastYMToDays(y) - _exsltDateCastYMToDays(x);
1729
113
        ret->day += y->day - x->day;
1730
113
        ret->day += carry;
1731
113
    }
1732
1733
187
    return ret;
1734
192
}
1735
1736
/**
1737
 * _exsltDateAddDurCalc
1738
 * @ret: an exsltDateDurValPtr for the return value:
1739
 * @x: an exsltDateDurValPtr for the first operand
1740
 * @y: an exsltDateDurValPtr for the second operand
1741
 *
1742
 * Add two durations, catering for possible negative values.
1743
 * The sum is placed in @ret.
1744
 *
1745
 * Returns 1 for success, 0 if error detected.
1746
 */
1747
static int
1748
_exsltDateAddDurCalc (exsltDateDurValPtr ret, exsltDateDurValPtr x,
1749
          exsltDateDurValPtr y)
1750
1.53k
{
1751
    /* months */
1752
1.53k
    if ((x->mon > 0 && y->mon > LONG_MAX - x->mon) ||
1753
1.53k
        (x->mon < 0 && y->mon < LONG_MIN - x->mon)) {
1754
        /* Overflow */
1755
0
        return 0;
1756
0
    }
1757
1.53k
    ret->mon = x->mon + y->mon;
1758
1759
    /* days */
1760
1.53k
    if ((x->day > 0 && y->day > LONG_MAX - x->day) ||
1761
1.53k
        (x->day < 0 && y->day < LONG_MIN - x->day)) {
1762
        /* Overflow */
1763
0
        return 0;
1764
0
    }
1765
1.53k
    ret->day = x->day + y->day;
1766
1767
    /* seconds */
1768
1.53k
    ret->sec = x->sec + y->sec;
1769
1.53k
    if (ret->sec >= SECS_PER_DAY) {
1770
464
        if (ret->day == LONG_MAX) {
1771
            /* Overflow */
1772
0
            return 0;
1773
0
        }
1774
464
        ret->sec -= SECS_PER_DAY;
1775
464
        ret->day += 1;
1776
464
    }
1777
1778
    /*
1779
     * are the results indeterminate? i.e. how do you subtract days from
1780
     * months or years?
1781
     */
1782
1.53k
    if (ret->day >= 0) {
1783
619
        if (((ret->day > 0) || (ret->sec > 0)) && (ret->mon < 0))
1784
29
            return 0;
1785
619
    }
1786
911
    else {
1787
911
        if (ret->mon > 0)
1788
16
            return 0;
1789
911
    }
1790
1.48k
    return 1;
1791
1.53k
}
1792
1793
/**
1794
 * _exsltDateAddDuration:
1795
 * @x: an #exsltDateDurValPtr
1796
 * @y: an #exsltDateDurValPtr
1797
 *
1798
 * Compute a new duration from @x and @y.
1799
 *
1800
 * Returns a duration pointer or NULL.
1801
 */
1802
static exsltDateDurValPtr
1803
_exsltDateAddDuration (exsltDateDurValPtr x, exsltDateDurValPtr y)
1804
68
{
1805
68
    exsltDateDurValPtr ret;
1806
1807
68
    if ((x == NULL) || (y == NULL))
1808
0
        return NULL;
1809
1810
68
    ret = exsltDateCreateDuration();
1811
68
    if (ret == NULL)
1812
0
        return NULL;
1813
1814
68
    if (_exsltDateAddDurCalc(ret, x, y))
1815
67
        return ret;
1816
1817
1
    exsltDateFreeDuration(ret);
1818
1
    return NULL;
1819
68
}
1820
1821
/****************************************************************
1822
 *                *
1823
 *    EXSLT - Dates and Times functions   *
1824
 *                *
1825
 ****************************************************************/
1826
1827
/**
1828
 * exsltDateDateTime:
1829
 *
1830
 * Implements the EXSLT - Dates and Times date-time() function:
1831
 *     string date:date-time()
1832
 *
1833
 * Returns the current date and time as a date/time string.
1834
 */
1835
static xmlChar *
1836
exsltDateDateTime (void)
1837
18
{
1838
18
    xmlChar *ret = NULL;
1839
18
    exsltDateValPtr cur;
1840
1841
18
    cur = exsltDateCurrent();
1842
18
    if (cur != NULL) {
1843
18
  ret = exsltDateFormatDateTime(cur);
1844
18
  exsltDateFreeDate(cur);
1845
18
    }
1846
1847
18
    return ret;
1848
18
}
1849
1850
/**
1851
 * exsltDateDate:
1852
 * @dateTime: a date/time string
1853
 *
1854
 * Implements the EXSLT - Dates and Times date() function:
1855
 *     string date:date (string?)
1856
 *
1857
 * Returns the date specified in the date/time string given as the
1858
 * argument.  If no argument is given, then the current local
1859
 * date/time, as returned by date:date-time is used as a default
1860
 * argument.
1861
 * The date/time string specified as an argument must be a string in
1862
 * the format defined as the lexical representation of either
1863
 * xs:dateTime or xs:date.  If the argument is not in either of these
1864
 * formats, returns NULL.
1865
 */
1866
static xmlChar *
1867
exsltDateDate (const xmlChar *dateTime)
1868
828
{
1869
828
    exsltDateValPtr dt = NULL;
1870
828
    xmlChar *ret = NULL;
1871
1872
828
    if (dateTime == NULL) {
1873
19
  dt = exsltDateCurrent();
1874
19
  if (dt == NULL)
1875
0
      return NULL;
1876
809
    } else {
1877
809
  dt = exsltDateParse(dateTime);
1878
809
  if (dt == NULL)
1879
733
      return NULL;
1880
76
  if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) {
1881
32
      exsltDateFreeDate(dt);
1882
32
      return NULL;
1883
32
  }
1884
76
    }
1885
1886
63
    ret = exsltDateFormatDate(dt);
1887
63
    exsltDateFreeDate(dt);
1888
1889
63
    return ret;
1890
828
}
1891
1892
/**
1893
 * exsltDateTime:
1894
 * @dateTime: a date/time string
1895
 *
1896
 * Implements the EXSLT - Dates and Times time() function:
1897
 *     string date:time (string?)
1898
 *
1899
 * Returns the time specified in the date/time string given as the
1900
 * argument.  If no argument is given, then the current local
1901
 * date/time, as returned by date:date-time is used as a default
1902
 * argument.
1903
 * The date/time string specified as an argument must be a string in
1904
 * the format defined as the lexical representation of either
1905
 * xs:dateTime or xs:time.  If the argument is not in either of these
1906
 * formats, returns NULL.
1907
 */
1908
static xmlChar *
1909
exsltDateTime (const xmlChar *dateTime)
1910
208
{
1911
208
    exsltDateValPtr dt = NULL;
1912
208
    xmlChar *ret = NULL;
1913
1914
208
    if (dateTime == NULL) {
1915
15
  dt = exsltDateCurrent();
1916
15
  if (dt == NULL)
1917
0
      return NULL;
1918
193
    } else {
1919
193
  dt = exsltDateParse(dateTime);
1920
193
  if (dt == NULL)
1921
144
      return NULL;
1922
49
  if ((dt->type != XS_DATETIME) && (dt->type != XS_TIME)) {
1923
18
      exsltDateFreeDate(dt);
1924
18
      return NULL;
1925
18
  }
1926
49
    }
1927
1928
46
    ret = exsltDateFormatTime(dt);
1929
46
    exsltDateFreeDate(dt);
1930
1931
46
    return ret;
1932
208
}
1933
1934
/**
1935
 * exsltDateYear:
1936
 * @dateTime: a date/time string
1937
 *
1938
 * Implements the EXSLT - Dates and Times year() function
1939
 *    number date:year (string?)
1940
 * Returns the year of a date as a number.  If no argument is given,
1941
 * then the current local date/time, as returned by date:date-time is
1942
 * used as a default argument.
1943
 * The date/time string specified as the first argument must be a
1944
 * right-truncated string in the format defined as the lexical
1945
 * representation of xs:dateTime in one of the formats defined in [XML
1946
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
1947
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
1948
 *  - xs:date (CCYY-MM-DD)
1949
 *  - xs:gYearMonth (CCYY-MM)
1950
 *  - xs:gYear (CCYY)
1951
 * If the date/time string is not in one of these formats, then NaN is
1952
 * returned.
1953
 */
1954
static double
1955
exsltDateYear (const xmlChar *dateTime)
1956
1.40k
{
1957
1.40k
    exsltDateValPtr dt;
1958
1.40k
    long year;
1959
1.40k
    double ret;
1960
1961
1.40k
    if (dateTime == NULL) {
1962
16
  dt = exsltDateCurrent();
1963
16
  if (dt == NULL)
1964
0
      return xmlXPathNAN;
1965
1.39k
    } else {
1966
1.39k
  dt = exsltDateParse(dateTime);
1967
1.39k
  if (dt == NULL)
1968
1.32k
      return xmlXPathNAN;
1969
67
  if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE) &&
1970
67
      (dt->type != XS_GYEARMONTH) && (dt->type != XS_GYEAR)) {
1971
12
      exsltDateFreeDate(dt);
1972
12
      return xmlXPathNAN;
1973
12
  }
1974
67
    }
1975
1976
71
    year = dt->year;
1977
71
    if (year <= 0) year -= 1; /* Adjust for missing year 0. */
1978
71
    ret = (double) year;
1979
71
    exsltDateFreeDate(dt);
1980
1981
71
    return ret;
1982
1.40k
}
1983
1984
/**
1985
 * exsltDateLeapYear:
1986
 * @dateTime: a date/time string
1987
 *
1988
 * Implements the EXSLT - Dates and Times leap-year() function:
1989
 *    boolean date:leap-yea (string?)
1990
 * Returns true if the year given in a date is a leap year.  If no
1991
 * argument is given, then the current local date/time, as returned by
1992
 * date:date-time is used as a default argument.
1993
 * The date/time string specified as the first argument must be a
1994
 * right-truncated string in the format defined as the lexical
1995
 * representation of xs:dateTime in one of the formats defined in [XML
1996
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
1997
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
1998
 *  - xs:date (CCYY-MM-DD)
1999
 *  - xs:gYearMonth (CCYY-MM)
2000
 *  - xs:gYear (CCYY)
2001
 * If the date/time string is not in one of these formats, then NaN is
2002
 * returned.
2003
 */
2004
static xmlXPathObjectPtr
2005
exsltDateLeapYear (const xmlChar *dateTime)
2006
145
{
2007
145
    exsltDateValPtr dt = NULL;
2008
145
    xmlXPathObjectPtr ret;
2009
2010
145
    if (dateTime == NULL) {
2011
16
  dt = exsltDateCurrent();
2012
129
    } else {
2013
129
  dt = exsltDateParse(dateTime);
2014
129
  if ((dt != NULL) &&
2015
129
            (dt->type != XS_DATETIME) && (dt->type != XS_DATE) &&
2016
129
      (dt->type != XS_GYEARMONTH) && (dt->type != XS_GYEAR)) {
2017
15
      exsltDateFreeDate(dt);
2018
15
      dt = NULL;
2019
15
  }
2020
129
    }
2021
2022
145
    if (dt == NULL) {
2023
60
        ret = xmlXPathNewFloat(xmlXPathNAN);
2024
60
    }
2025
85
    else {
2026
85
        ret = xmlXPathNewBoolean(IS_LEAP(dt->year));
2027
85
        exsltDateFreeDate(dt);
2028
85
    }
2029
2030
145
    return ret;
2031
145
}
2032
2033
/**
2034
 * exsltDateMonthInYear:
2035
 * @dateTime: a date/time string
2036
 *
2037
 * Implements the EXSLT - Dates and Times month-in-year() function:
2038
 *    number date:month-in-year (string?)
2039
 * Returns the month of a date as a number.  If no argument is given,
2040
 * then the current local date/time, as returned by date:date-time is
2041
 * used the default argument.
2042
 * The date/time string specified as the argument is a left or
2043
 * right-truncated string in the format defined as the lexical
2044
 * representation of xs:dateTime in one of the formats defined in [XML
2045
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
2046
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2047
 *  - xs:date (CCYY-MM-DD)
2048
 *  - xs:gYearMonth (CCYY-MM)
2049
 *  - xs:gMonth (--MM--)
2050
 *  - xs:gMonthDay (--MM-DD)
2051
 * If the date/time string is not in one of these formats, then NaN is
2052
 * returned.
2053
 */
2054
static double
2055
exsltDateMonthInYear (const xmlChar *dateTime)
2056
346
{
2057
346
    exsltDateValPtr dt;
2058
346
    double ret;
2059
2060
346
    if (dateTime == NULL) {
2061
42
  dt = exsltDateCurrent();
2062
42
  if (dt == NULL)
2063
0
      return xmlXPathNAN;
2064
304
    } else {
2065
304
  dt = exsltDateParse(dateTime);
2066
304
  if (dt == NULL)
2067
197
      return xmlXPathNAN;
2068
107
  if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE) &&
2069
107
      (dt->type != XS_GYEARMONTH) && (dt->type != XS_GMONTH) &&
2070
107
      (dt->type != XS_GMONTHDAY)) {
2071
32
      exsltDateFreeDate(dt);
2072
32
      return xmlXPathNAN;
2073
32
  }
2074
107
    }
2075
2076
117
    ret = (double) dt->mon;
2077
117
    exsltDateFreeDate(dt);
2078
2079
117
    return ret;
2080
346
}
2081
2082
/**
2083
 * exsltDateMonthName:
2084
 * @dateTime: a date/time string
2085
 *
2086
 * Implements the EXSLT - Dates and Time month-name() function
2087
 *    string date:month-name (string?)
2088
 * Returns the full name of the month of a date.  If no argument is
2089
 * given, then the current local date/time, as returned by
2090
 * date:date-time is used the default argument.
2091
 * The date/time string specified as the argument is a left or
2092
 * right-truncated string in the format defined as the lexical
2093
 * representation of xs:dateTime in one of the formats defined in [XML
2094
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
2095
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2096
 *  - xs:date (CCYY-MM-DD)
2097
 *  - xs:gYearMonth (CCYY-MM)
2098
 *  - xs:gMonth (--MM--)
2099
 * If the date/time string is not in one of these formats, then an
2100
 * empty string ('') is returned.
2101
 * The result is an English month name: one of 'January', 'February',
2102
 * 'March', 'April', 'May', 'June', 'July', 'August', 'September',
2103
 * 'October', 'November' or 'December'.
2104
 */
2105
static const xmlChar *
2106
exsltDateMonthName (const xmlChar *dateTime)
2107
150
{
2108
150
    static const xmlChar monthNames[13][10] = {
2109
150
        { 0 },
2110
150
  { 'J', 'a', 'n', 'u', 'a', 'r', 'y', 0 },
2111
150
  { 'F', 'e', 'b', 'r', 'u', 'a', 'r', 'y', 0 },
2112
150
  { 'M', 'a', 'r', 'c', 'h', 0 },
2113
150
  { 'A', 'p', 'r', 'i', 'l', 0 },
2114
150
  { 'M', 'a', 'y', 0 },
2115
150
  { 'J', 'u', 'n', 'e', 0 },
2116
150
  { 'J', 'u', 'l', 'y', 0 },
2117
150
  { 'A', 'u', 'g', 'u', 's', 't', 0 },
2118
150
  { 'S', 'e', 'p', 't', 'e', 'm', 'b', 'e', 'r', 0 },
2119
150
  { 'O', 'c', 't', 'o', 'b', 'e', 'r', 0 },
2120
150
  { 'N', 'o', 'v', 'e', 'm', 'b', 'e', 'r', 0 },
2121
150
  { 'D', 'e', 'c', 'e', 'm', 'b', 'e', 'r', 0 }
2122
150
    };
2123
150
    double month;
2124
150
    int index = 0;
2125
150
    month = exsltDateMonthInYear(dateTime);
2126
150
    if (!xmlXPathIsNaN(month) && (month >= 1.0) && (month <= 12.0))
2127
36
      index = (int) month;
2128
150
    return monthNames[index];
2129
150
}
2130
2131
/**
2132
 * exsltDateMonthAbbreviation:
2133
 * @dateTime: a date/time string
2134
 *
2135
 * Implements the EXSLT - Dates and Time month-abbreviation() function
2136
 *    string date:month-abbreviation (string?)
2137
 * Returns the abbreviation of the month of a date.  If no argument is
2138
 * given, then the current local date/time, as returned by
2139
 * date:date-time is used the default argument.
2140
 * The date/time string specified as the argument is a left or
2141
 * right-truncated string in the format defined as the lexical
2142
 * representation of xs:dateTime in one of the formats defined in [XML
2143
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
2144
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2145
 *  - xs:date (CCYY-MM-DD)
2146
 *  - xs:gYearMonth (CCYY-MM)
2147
 *  - xs:gMonth (--MM--)
2148
 * If the date/time string is not in one of these formats, then an
2149
 * empty string ('') is returned.
2150
 * The result is an English month abbreviation: one of 'Jan', 'Feb',
2151
 * 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov' or
2152
 * 'Dec'.
2153
 */
2154
static const xmlChar *
2155
exsltDateMonthAbbreviation (const xmlChar *dateTime)
2156
83
{
2157
83
    static const xmlChar monthAbbreviations[13][4] = {
2158
83
        { 0 },
2159
83
  { 'J', 'a', 'n', 0 },
2160
83
  { 'F', 'e', 'b', 0 },
2161
83
  { 'M', 'a', 'r', 0 },
2162
83
  { 'A', 'p', 'r', 0 },
2163
83
  { 'M', 'a', 'y', 0 },
2164
83
  { 'J', 'u', 'n', 0 },
2165
83
  { 'J', 'u', 'l', 0 },
2166
83
  { 'A', 'u', 'g', 0 },
2167
83
  { 'S', 'e', 'p', 0 },
2168
83
  { 'O', 'c', 't', 0 },
2169
83
  { 'N', 'o', 'v', 0 },
2170
83
  { 'D', 'e', 'c', 0 }
2171
83
    };
2172
83
    double month;
2173
83
    int index = 0;
2174
83
    month = exsltDateMonthInYear(dateTime);
2175
83
    if (!xmlXPathIsNaN(month) && (month >= 1.0) && (month <= 12.0))
2176
37
      index = (int) month;
2177
83
    return monthAbbreviations[index];
2178
83
}
2179
2180
/**
2181
 * exsltDateWeekInYear:
2182
 * @dateTime: a date/time string
2183
 *
2184
 * Implements the EXSLT - Dates and Times week-in-year() function
2185
 *    number date:week-in-year (string?)
2186
 * Returns the week of the year as a number.  If no argument is given,
2187
 * then the current local date/time, as returned by date:date-time is
2188
 * used as the default argument.  For the purposes of numbering,
2189
 * counting follows ISO 8601: week 1 in a year is the week containing
2190
 * the first Thursday of the year, with new weeks beginning on a
2191
 * Monday.
2192
 * The date/time string specified as the argument is a right-truncated
2193
 * string in the format defined as the lexical representation of
2194
 * xs:dateTime in one of the formats defined in [XML Schema Part 2:
2195
 * Datatypes].  The permitted formats are as follows:
2196
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2197
 *  - xs:date (CCYY-MM-DD)
2198
 * If the date/time string is not in one of these formats, then NaN is
2199
 * returned.
2200
 */
2201
static double
2202
exsltDateWeekInYear (const xmlChar *dateTime)
2203
1.02k
{
2204
1.02k
    exsltDateValPtr dt;
2205
1.02k
    long diy, diw, year, ret;
2206
2207
1.02k
    if (dateTime == NULL) {
2208
14
  dt = exsltDateCurrent();
2209
14
  if (dt == NULL)
2210
0
      return xmlXPathNAN;
2211
1.01k
    } else {
2212
1.01k
  dt = exsltDateParse(dateTime);
2213
1.01k
  if (dt == NULL)
2214
963
      return xmlXPathNAN;
2215
47
  if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) {
2216
10
      exsltDateFreeDate(dt);
2217
10
      return xmlXPathNAN;
2218
10
  }
2219
47
    }
2220
2221
51
    diy = DAY_IN_YEAR(dt->day, dt->mon, dt->year);
2222
2223
    /*
2224
     * Determine day-in-week (0=Sun, 1=Mon, etc.) then adjust so Monday
2225
     * is the first day-in-week
2226
     */
2227
51
    diw = (_exsltDateDayInWeek(diy, dt->year) + 6) % 7;
2228
2229
    /* ISO 8601 adjustment, 3 is Thu */
2230
51
    diy += (3 - diw);
2231
51
    if(diy < 1) {
2232
21
  year = dt->year - 1;
2233
21
  if(year == 0) year--;
2234
21
  diy = DAY_IN_YEAR(31, 12, year) + diy;
2235
30
    } else if (diy > (long)DAY_IN_YEAR(31, 12, dt->year)) {
2236
0
  diy -= DAY_IN_YEAR(31, 12, dt->year);
2237
0
    }
2238
2239
51
    ret = ((diy - 1) / 7) + 1;
2240
2241
51
    exsltDateFreeDate(dt);
2242
2243
51
    return (double) ret;
2244
1.02k
}
2245
2246
/**
2247
 * exsltDateWeekInMonth:
2248
 * @dateTime: a date/time string
2249
 *
2250
 * Implements the EXSLT - Dates and Times week-in-month() function
2251
 *    number date:week-in-month (string?)
2252
 * The date:week-in-month function returns the week in a month of a
2253
 * date as a number. If no argument is given, then the current local
2254
 * date/time, as returned by date:date-time is used the default
2255
 * argument. For the purposes of numbering, the first day of the month
2256
 * is in week 1 and new weeks begin on a Monday (so the first and last
2257
 * weeks in a month will often have less than 7 days in them).
2258
 * The date/time string specified as the argument is a right-truncated
2259
 * string in the format defined as the lexical representation of
2260
 * xs:dateTime in one of the formats defined in [XML Schema Part 2:
2261
 * Datatypes].  The permitted formats are as follows:
2262
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2263
 *  - xs:date (CCYY-MM-DD)
2264
 * If the date/time string is not in one of these formats, then NaN is
2265
 * returned.
2266
 */
2267
static double
2268
exsltDateWeekInMonth (const xmlChar *dateTime)
2269
109
{
2270
109
    exsltDateValPtr dt;
2271
109
    long fdiy, fdiw, ret;
2272
2273
109
    if (dateTime == NULL) {
2274
12
  dt = exsltDateCurrent();
2275
12
  if (dt == NULL)
2276
0
      return xmlXPathNAN;
2277
97
    } else {
2278
97
  dt = exsltDateParse(dateTime);
2279
97
  if (dt == NULL)
2280
52
      return xmlXPathNAN;
2281
45
  if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) {
2282
15
      exsltDateFreeDate(dt);
2283
15
      return xmlXPathNAN;
2284
15
  }
2285
45
    }
2286
2287
42
    fdiy = DAY_IN_YEAR(1, dt->mon, dt->year);
2288
    /*
2289
     * Determine day-in-week (0=Sun, 1=Mon, etc.) then adjust so Monday
2290
     * is the first day-in-week
2291
     */
2292
42
    fdiw = (_exsltDateDayInWeek(fdiy, dt->year) + 6) % 7;
2293
2294
42
    ret = ((dt->day + fdiw - 1) / 7) + 1;
2295
2296
42
    exsltDateFreeDate(dt);
2297
2298
42
    return (double) ret;
2299
109
}
2300
2301
/**
2302
 * exsltDateDayInYear:
2303
 * @dateTime: a date/time string
2304
 *
2305
 * Implements the EXSLT - Dates and Times day-in-year() function
2306
 *    number date:day-in-year (string?)
2307
 * Returns the day of a date in a year as a number.  If no argument is
2308
 * given, then the current local date/time, as returned by
2309
 * date:date-time is used the default argument.
2310
 * The date/time string specified as the argument is a right-truncated
2311
 * string in the format defined as the lexical representation of
2312
 * xs:dateTime in one of the formats defined in [XML Schema Part 2:
2313
 * Datatypes].  The permitted formats are as follows:
2314
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2315
 *  - xs:date (CCYY-MM-DD)
2316
 * If the date/time string is not in one of these formats, then NaN is
2317
 * returned.
2318
 */
2319
static double
2320
exsltDateDayInYear (const xmlChar *dateTime)
2321
108
{
2322
108
    exsltDateValPtr dt;
2323
108
    long ret;
2324
2325
108
    if (dateTime == NULL) {
2326
13
  dt = exsltDateCurrent();
2327
13
  if (dt == NULL)
2328
0
      return xmlXPathNAN;
2329
95
    } else {
2330
95
  dt = exsltDateParse(dateTime);
2331
95
  if (dt == NULL)
2332
56
      return xmlXPathNAN;
2333
39
  if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) {
2334
15
      exsltDateFreeDate(dt);
2335
15
      return xmlXPathNAN;
2336
15
  }
2337
39
    }
2338
2339
37
    ret = DAY_IN_YEAR(dt->day, dt->mon, dt->year);
2340
2341
37
    exsltDateFreeDate(dt);
2342
2343
37
    return (double) ret;
2344
108
}
2345
2346
/**
2347
 * exsltDateDayInMonth:
2348
 * @dateTime: a date/time string
2349
 *
2350
 * Implements the EXSLT - Dates and Times day-in-month() function:
2351
 *    number date:day-in-month (string?)
2352
 * Returns the day of a date as a number.  If no argument is given,
2353
 * then the current local date/time, as returned by date:date-time is
2354
 * used the default argument.
2355
 * The date/time string specified as the argument is a left or
2356
 * right-truncated string in the format defined as the lexical
2357
 * representation of xs:dateTime in one of the formats defined in [XML
2358
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
2359
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2360
 *  - xs:date (CCYY-MM-DD)
2361
 *  - xs:gMonthDay (--MM-DD)
2362
 *  - xs:gDay (---DD)
2363
 * If the date/time string is not in one of these formats, then NaN is
2364
 * returned.
2365
 */
2366
static double
2367
exsltDateDayInMonth (const xmlChar *dateTime)
2368
115
{
2369
115
    exsltDateValPtr dt;
2370
115
    double ret;
2371
2372
115
    if (dateTime == NULL) {
2373
18
  dt = exsltDateCurrent();
2374
18
  if (dt == NULL)
2375
0
      return xmlXPathNAN;
2376
97
    } else {
2377
97
  dt = exsltDateParse(dateTime);
2378
97
  if (dt == NULL)
2379
59
      return xmlXPathNAN;
2380
38
  if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE) &&
2381
38
      (dt->type != XS_GMONTHDAY) && (dt->type != XS_GDAY)) {
2382
18
      exsltDateFreeDate(dt);
2383
18
      return xmlXPathNAN;
2384
18
  }
2385
38
    }
2386
2387
38
    ret = (double) dt->day;
2388
38
    exsltDateFreeDate(dt);
2389
2390
38
    return ret;
2391
115
}
2392
2393
/**
2394
 * exsltDateDayOfWeekInMonth:
2395
 * @dateTime: a date/time string
2396
 *
2397
 * Implements the EXSLT - Dates and Times day-of-week-in-month() function:
2398
 *    number date:day-of-week-in-month (string?)
2399
 * Returns the day-of-the-week in a month of a date as a number
2400
 * (e.g. 3 for the 3rd Tuesday in May).  If no argument is
2401
 * given, then the current local date/time, as returned by
2402
 * date:date-time is used the default argument.
2403
 * The date/time string specified as the argument is a right-truncated
2404
 * string in the format defined as the lexical representation of
2405
 * xs:dateTime in one of the formats defined in [XML Schema Part 2:
2406
 * Datatypes].  The permitted formats are as follows:
2407
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2408
 *  - xs:date (CCYY-MM-DD)
2409
 * If the date/time string is not in one of these formats, then NaN is
2410
 * returned.
2411
 */
2412
static double
2413
exsltDateDayOfWeekInMonth (const xmlChar *dateTime)
2414
88
{
2415
88
    exsltDateValPtr dt;
2416
88
    long ret;
2417
2418
88
    if (dateTime == NULL) {
2419
13
  dt = exsltDateCurrent();
2420
13
  if (dt == NULL)
2421
0
      return xmlXPathNAN;
2422
75
    } else {
2423
75
  dt = exsltDateParse(dateTime);
2424
75
  if (dt == NULL)
2425
46
      return xmlXPathNAN;
2426
29
  if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) {
2427
13
      exsltDateFreeDate(dt);
2428
13
      return xmlXPathNAN;
2429
13
  }
2430
29
    }
2431
2432
29
    ret = ((dt->day -1) / 7) + 1;
2433
2434
29
    exsltDateFreeDate(dt);
2435
2436
29
    return (double) ret;
2437
88
}
2438
2439
/**
2440
 * exsltDateDayInWeek:
2441
 * @dateTime: a date/time string
2442
 *
2443
 * Implements the EXSLT - Dates and Times day-in-week() function:
2444
 *    number date:day-in-week (string?)
2445
 * Returns the day of the week given in a date as a number.  If no
2446
 * argument is given, then the current local date/time, as returned by
2447
 * date:date-time is used the default argument.
2448
 * The date/time string specified as the argument is a left or
2449
 * right-truncated string in the format defined as the lexical
2450
 * representation of xs:dateTime in one of the formats defined in [XML
2451
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
2452
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2453
 *  - xs:date (CCYY-MM-DD)
2454
 * If the date/time string is not in one of these formats, then NaN is
2455
 * returned.
2456
 * The numbering of days of the week starts at 1 for Sunday, 2 for
2457
 * Monday and so on up to 7 for Saturday.
2458
 */
2459
static double
2460
exsltDateDayInWeek (const xmlChar *dateTime)
2461
356
{
2462
356
    exsltDateValPtr dt;
2463
356
    long diy, ret;
2464
2465
356
    if (dateTime == NULL) {
2466
46
  dt = exsltDateCurrent();
2467
46
  if (dt == NULL)
2468
0
      return xmlXPathNAN;
2469
310
    } else {
2470
310
  dt = exsltDateParse(dateTime);
2471
310
  if (dt == NULL)
2472
227
      return xmlXPathNAN;
2473
83
  if ((dt->type != XS_DATETIME) && (dt->type != XS_DATE)) {
2474
19
      exsltDateFreeDate(dt);
2475
19
      return xmlXPathNAN;
2476
19
  }
2477
83
    }
2478
2479
110
    diy = DAY_IN_YEAR(dt->day, dt->mon, dt->year);
2480
2481
110
    ret = _exsltDateDayInWeek(diy, dt->year) + 1;
2482
2483
110
    exsltDateFreeDate(dt);
2484
2485
110
    return (double) ret;
2486
356
}
2487
2488
/**
2489
 * exsltDateDayName:
2490
 * @dateTime: a date/time string
2491
 *
2492
 * Implements the EXSLT - Dates and Time day-name() function
2493
 *    string date:day-name (string?)
2494
 * Returns the full name of the day of the week of a date.  If no
2495
 * argument is given, then the current local date/time, as returned by
2496
 * date:date-time is used the default argument.
2497
 * The date/time string specified as the argument is a left or
2498
 * right-truncated string in the format defined as the lexical
2499
 * representation of xs:dateTime in one of the formats defined in [XML
2500
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
2501
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2502
 *  - xs:date (CCYY-MM-DD)
2503
 * If the date/time string is not in one of these formats, then an
2504
 * empty string ('') is returned.
2505
 * The result is an English day name: one of 'Sunday', 'Monday',
2506
 * 'Tuesday', 'Wednesday', 'Thursday' or 'Friday'.
2507
 */
2508
static const xmlChar *
2509
exsltDateDayName (const xmlChar *dateTime)
2510
247
{
2511
247
    static const xmlChar dayNames[8][10] = {
2512
247
        { 0 },
2513
247
  { 'S', 'u', 'n', 'd', 'a', 'y', 0 },
2514
247
  { 'M', 'o', 'n', 'd', 'a', 'y', 0 },
2515
247
  { 'T', 'u', 'e', 's', 'd', 'a', 'y', 0 },
2516
247
  { 'W', 'e', 'd', 'n', 'e', 's', 'd', 'a', 'y', 0 },
2517
247
  { 'T', 'h', 'u', 'r', 's', 'd', 'a', 'y', 0 },
2518
247
  { 'F', 'r', 'i', 'd', 'a', 'y', 0 },
2519
247
  { 'S', 'a', 't', 'u', 'r', 'd', 'a', 'y', 0 }
2520
247
    };
2521
247
    double day;
2522
247
    int index = 0;
2523
247
    day = exsltDateDayInWeek(dateTime);
2524
247
    if(!xmlXPathIsNaN(day) && (day >= 1.0) && (day <= 7.0))
2525
44
      index = (int) day;
2526
247
    return dayNames[index];
2527
247
}
2528
2529
/**
2530
 * exsltDateDayAbbreviation:
2531
 * @dateTime: a date/time string
2532
 *
2533
 * Implements the EXSLT - Dates and Time day-abbreviation() function
2534
 *    string date:day-abbreviation (string?)
2535
 * Returns the abbreviation of the day of the week of a date.  If no
2536
 * argument is given, then the current local date/time, as returned by
2537
 * date:date-time is used the default argument.
2538
 * The date/time string specified as the argument is a left or
2539
 * right-truncated string in the format defined as the lexical
2540
 * representation of xs:dateTime in one of the formats defined in [XML
2541
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
2542
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2543
 *  - xs:date (CCYY-MM-DD)
2544
 * If the date/time string is not in one of these formats, then an
2545
 * empty string ('') is returned.
2546
 * The result is a three-letter English day abbreviation: one of
2547
 * 'Sun', 'Mon', 'Tue', 'Wed', 'Thu' or 'Fri'.
2548
 */
2549
static const xmlChar *
2550
exsltDateDayAbbreviation (const xmlChar *dateTime)
2551
57
{
2552
57
    static const xmlChar dayAbbreviations[8][4] = {
2553
57
        { 0 },
2554
57
  { 'S', 'u', 'n', 0 },
2555
57
  { 'M', 'o', 'n', 0 },
2556
57
  { 'T', 'u', 'e', 0 },
2557
57
  { 'W', 'e', 'd', 0 },
2558
57
  { 'T', 'h', 'u', 0 },
2559
57
  { 'F', 'r', 'i', 0 },
2560
57
  { 'S', 'a', 't', 0 }
2561
57
    };
2562
57
    double day;
2563
57
    int index = 0;
2564
57
    day = exsltDateDayInWeek(dateTime);
2565
57
    if(!xmlXPathIsNaN(day) && (day >= 1.0) && (day <= 7.0))
2566
34
      index = (int) day;
2567
57
    return dayAbbreviations[index];
2568
57
}
2569
2570
/**
2571
 * exsltDateHourInDay:
2572
 * @dateTime: a date/time string
2573
 *
2574
 * Implements the EXSLT - Dates and Times day-in-month() function:
2575
 *    number date:day-in-month (string?)
2576
 * Returns the hour of the day as a number.  If no argument is given,
2577
 * then the current local date/time, as returned by date:date-time is
2578
 * used the default argument.
2579
 * The date/time string specified as the argument is a left or
2580
 * right-truncated string in the format defined as the lexical
2581
 * representation of xs:dateTime in one of the formats defined in [XML
2582
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
2583
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2584
 *  - xs:time (hh:mm:ss)
2585
 * If the date/time string is not in one of these formats, then NaN is
2586
 * returned.
2587
 */
2588
static double
2589
exsltDateHourInDay (const xmlChar *dateTime)
2590
126
{
2591
126
    exsltDateValPtr dt;
2592
126
    double ret;
2593
2594
126
    if (dateTime == NULL) {
2595
15
  dt = exsltDateCurrent();
2596
15
  if (dt == NULL)
2597
0
      return xmlXPathNAN;
2598
111
    } else {
2599
111
  dt = exsltDateParse(dateTime);
2600
111
  if (dt == NULL)
2601
73
      return xmlXPathNAN;
2602
38
  if ((dt->type != XS_DATETIME) && (dt->type != XS_TIME)) {
2603
15
      exsltDateFreeDate(dt);
2604
15
      return xmlXPathNAN;
2605
15
  }
2606
38
    }
2607
2608
38
    ret = (double) dt->hour;
2609
38
    exsltDateFreeDate(dt);
2610
2611
38
    return ret;
2612
126
}
2613
2614
/**
2615
 * exsltDateMinuteInHour:
2616
 * @dateTime: a date/time string
2617
 *
2618
 * Implements the EXSLT - Dates and Times day-in-month() function:
2619
 *    number date:day-in-month (string?)
2620
 * Returns the minute of the hour as a number.  If no argument is
2621
 * given, then the current local date/time, as returned by
2622
 * date:date-time is used the default argument.
2623
 * The date/time string specified as the argument is a left or
2624
 * right-truncated string in the format defined as the lexical
2625
 * representation of xs:dateTime in one of the formats defined in [XML
2626
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
2627
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2628
 *  - xs:time (hh:mm:ss)
2629
 * If the date/time string is not in one of these formats, then NaN is
2630
 * returned.
2631
 */
2632
static double
2633
exsltDateMinuteInHour (const xmlChar *dateTime)
2634
112
{
2635
112
    exsltDateValPtr dt;
2636
112
    double ret;
2637
2638
112
    if (dateTime == NULL) {
2639
14
  dt = exsltDateCurrent();
2640
14
  if (dt == NULL)
2641
0
      return xmlXPathNAN;
2642
98
    } else {
2643
98
  dt = exsltDateParse(dateTime);
2644
98
  if (dt == NULL)
2645
57
      return xmlXPathNAN;
2646
41
  if ((dt->type != XS_DATETIME) && (dt->type != XS_TIME)) {
2647
16
      exsltDateFreeDate(dt);
2648
16
      return xmlXPathNAN;
2649
16
  }
2650
41
    }
2651
2652
39
    ret = (double) dt->min;
2653
39
    exsltDateFreeDate(dt);
2654
2655
39
    return ret;
2656
112
}
2657
2658
/**
2659
 * exsltDateSecondInMinute:
2660
 * @dateTime: a date/time string
2661
 *
2662
 * Implements the EXSLT - Dates and Times second-in-minute() function:
2663
 *    number date:day-in-month (string?)
2664
 * Returns the second of the minute as a number.  If no argument is
2665
 * given, then the current local date/time, as returned by
2666
 * date:date-time is used the default argument.
2667
 * The date/time string specified as the argument is a left or
2668
 * right-truncated string in the format defined as the lexical
2669
 * representation of xs:dateTime in one of the formats defined in [XML
2670
 * Schema Part 2: Datatypes].  The permitted formats are as follows:
2671
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2672
 *  - xs:time (hh:mm:ss)
2673
 * If the date/time string is not in one of these formats, then NaN is
2674
 * returned.
2675
 *
2676
 * Returns the second or NaN.
2677
 */
2678
static double
2679
exsltDateSecondInMinute (const xmlChar *dateTime)
2680
129
{
2681
129
    exsltDateValPtr dt;
2682
129
    double ret;
2683
2684
129
    if (dateTime == NULL) {
2685
17
  dt = exsltDateCurrent();
2686
17
  if (dt == NULL)
2687
0
      return xmlXPathNAN;
2688
112
    } else {
2689
112
  dt = exsltDateParse(dateTime);
2690
112
  if (dt == NULL)
2691
72
      return xmlXPathNAN;
2692
40
  if ((dt->type != XS_DATETIME) && (dt->type != XS_TIME)) {
2693
15
      exsltDateFreeDate(dt);
2694
15
      return xmlXPathNAN;
2695
15
  }
2696
40
    }
2697
2698
42
    ret = dt->sec;
2699
42
    exsltDateFreeDate(dt);
2700
2701
42
    return ret;
2702
129
}
2703
2704
/**
2705
 * exsltDateAdd:
2706
 * @xstr: date/time string
2707
 * @ystr: date/time string
2708
 *
2709
 * Implements the date:add (string,string) function which returns the
2710
 * date/time * resulting from adding a duration to a date/time.
2711
 * The first argument (@xstr) must be right-truncated date/time
2712
 * strings in one of the formats defined in [XML Schema Part 2:
2713
 * Datatypes]. The permitted formats are as follows:
2714
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2715
 *  - xs:date (CCYY-MM-DD)
2716
 *  - xs:gYearMonth (CCYY-MM)
2717
 *  - xs:gYear (CCYY)
2718
 * The second argument (@ystr) is a string in the format defined for
2719
 * xs:duration in [3.2.6 duration] of [XML Schema Part 2: Datatypes].
2720
 * The return value is a right-truncated date/time strings in one of
2721
 * the formats defined in [XML Schema Part 2: Datatypes] and listed
2722
 * above. This value is calculated using the algorithm described in
2723
 * [Appendix E Adding durations to dateTimes] of [XML Schema Part 2:
2724
 * Datatypes].
2725
2726
 * Returns date/time string or NULL.
2727
 */
2728
static xmlChar *
2729
exsltDateAdd (const xmlChar *xstr, const xmlChar *ystr)
2730
8.14k
{
2731
8.14k
    exsltDateValPtr dt, res;
2732
8.14k
    exsltDateDurValPtr dur;
2733
8.14k
    xmlChar     *ret;
2734
2735
8.14k
    if ((xstr == NULL) || (ystr == NULL))
2736
0
        return NULL;
2737
2738
8.14k
    dt = exsltDateParse(xstr);
2739
8.14k
    if (dt == NULL)
2740
7.63k
        return NULL;
2741
512
    else if ((dt->type < XS_GYEAR) || (dt->type > XS_DATETIME)) {
2742
17
        exsltDateFreeDate(dt);
2743
17
        return NULL;
2744
17
    }
2745
2746
495
    dur = exsltDateParseDuration(ystr);
2747
495
    if (dur == NULL) {
2748
226
        exsltDateFreeDate(dt);
2749
226
        return NULL;
2750
226
    }
2751
2752
269
    res = _exsltDateAdd(dt, dur);
2753
2754
269
    exsltDateFreeDate(dt);
2755
269
    exsltDateFreeDuration(dur);
2756
2757
269
    if (res == NULL)
2758
0
        return NULL;
2759
2760
269
    ret = exsltDateFormat(res);
2761
269
    exsltDateFreeDate(res);
2762
2763
269
    return ret;
2764
269
}
2765
2766
/**
2767
 * exsltDateAddDuration:
2768
 * @xstr:      first duration string
2769
 * @ystr:      second duration string
2770
 *
2771
 * Implements the date:add-duration (string,string) function which returns
2772
 * the duration resulting from adding two durations together.
2773
 * Both arguments are strings in the format defined for xs:duration
2774
 * in [3.2.6 duration] of [XML Schema Part 2: Datatypes]. If either
2775
 * argument is not in this format, the function returns an empty string
2776
 * ('').
2777
 * The return value is a string in the format defined for xs:duration
2778
 * in [3.2.6 duration] of [XML Schema Part 2: Datatypes].
2779
 * The durations can usually be added by summing the numbers given for
2780
 * each of the components in the durations. However, if the durations
2781
 * are differently signed, then this sometimes results in durations
2782
 * that are impossible to express in this syntax (e.g. 'P1M' + '-P1D').
2783
 * In these cases, the function returns an empty string ('').
2784
 *
2785
 * Returns duration string or NULL.
2786
 */
2787
static xmlChar *
2788
exsltDateAddDuration (const xmlChar *xstr, const xmlChar *ystr)
2789
204
{
2790
204
    exsltDateDurValPtr x, y, res;
2791
204
    xmlChar     *ret;
2792
2793
204
    if ((xstr == NULL) || (ystr == NULL))
2794
0
        return NULL;
2795
2796
204
    x = exsltDateParseDuration(xstr);
2797
204
    if (x == NULL)
2798
103
        return NULL;
2799
2800
101
    y = exsltDateParseDuration(ystr);
2801
101
    if (y == NULL) {
2802
33
        exsltDateFreeDuration(x);
2803
33
        return NULL;
2804
33
    }
2805
2806
68
    res = _exsltDateAddDuration(x, y);
2807
2808
68
    exsltDateFreeDuration(x);
2809
68
    exsltDateFreeDuration(y);
2810
2811
68
    if (res == NULL)
2812
1
        return NULL;
2813
2814
67
    ret = exsltDateFormatDuration(res);
2815
67
    exsltDateFreeDuration(res);
2816
2817
67
    return ret;
2818
68
}
2819
2820
/**
2821
 * exsltDateSumFunction:
2822
 * @ns:      a node set of duration strings
2823
 *
2824
 * The date:sum function adds a set of durations together.
2825
 * The string values of the nodes in the node set passed as an argument
2826
 * are interpreted as durations and added together as if using the
2827
 * date:add-duration function. (from exslt.org)
2828
 *
2829
 * The return value is a string in the format defined for xs:duration
2830
 * in [3.2.6 duration] of [XML Schema Part 2: Datatypes].
2831
 * The durations can usually be added by summing the numbers given for
2832
 * each of the components in the durations. However, if the durations
2833
 * are differently signed, then this sometimes results in durations
2834
 * that are impossible to express in this syntax (e.g. 'P1M' + '-P1D').
2835
 * In these cases, the function returns an empty string ('').
2836
 *
2837
 * Returns duration string or NULL.
2838
 */
2839
static void
2840
exsltDateSumFunction (xmlXPathParserContextPtr ctxt, int nargs)
2841
1.65k
{
2842
1.65k
    xmlNodeSetPtr ns;
2843
1.65k
    void *user = NULL;
2844
1.65k
    xmlChar *tmp;
2845
1.65k
    exsltDateDurValPtr x, total;
2846
1.65k
    xmlChar *ret;
2847
1.65k
    int i;
2848
2849
1.65k
    if (nargs != 1) {
2850
23
  xmlXPathSetArityError (ctxt);
2851
23
  return;
2852
23
    }
2853
2854
    /* We need to delay the freeing of value->user */
2855
1.63k
    if ((ctxt->value != NULL) && ctxt->value->boolval != 0) {
2856
37
  user = ctxt->value->user;
2857
37
  ctxt->value->boolval = 0;
2858
37
  ctxt->value->user = NULL;
2859
37
    }
2860
2861
1.63k
    ns = xmlXPathPopNodeSet (ctxt);
2862
1.63k
    if (xmlXPathCheckError (ctxt))
2863
55
  return;
2864
2865
1.57k
    if ((ns == NULL) || (ns->nodeNr == 0)) {
2866
31
  xmlXPathReturnEmptyString (ctxt);
2867
31
  if (ns != NULL)
2868
16
      xmlXPathFreeNodeSet (ns);
2869
31
  return;
2870
31
    }
2871
2872
1.54k
    total = exsltDateCreateDuration ();
2873
1.54k
    if (total == NULL) {
2874
0
        xmlXPathFreeNodeSet (ns);
2875
0
        return;
2876
0
    }
2877
2878
2.96k
    for (i = 0; i < ns->nodeNr; i++) {
2879
2.87k
  int result;
2880
2.87k
  tmp = xmlXPathCastNodeToString (ns->nodeTab[i]);
2881
2.87k
  if (tmp == NULL) {
2882
0
      xmlXPathFreeNodeSet (ns);
2883
0
      exsltDateFreeDuration (total);
2884
0
      return;
2885
0
  }
2886
2887
2.87k
  x = exsltDateParseDuration (tmp);
2888
2.87k
  if (x == NULL) {
2889
1.41k
      xmlFree (tmp);
2890
1.41k
      exsltDateFreeDuration (total);
2891
1.41k
      xmlXPathFreeNodeSet (ns);
2892
1.41k
      xmlXPathReturnEmptyString (ctxt);
2893
1.41k
      return;
2894
1.41k
  }
2895
2896
1.46k
  result = _exsltDateAddDurCalc(total, total, x);
2897
2898
1.46k
  exsltDateFreeDuration (x);
2899
1.46k
  xmlFree (tmp);
2900
1.46k
  if (!result) {
2901
44
      exsltDateFreeDuration (total);
2902
44
      xmlXPathFreeNodeSet (ns);
2903
44
      xmlXPathReturnEmptyString (ctxt);
2904
44
      return;
2905
44
  }
2906
1.46k
    }
2907
2908
87
    ret = exsltDateFormatDuration (total);
2909
87
    exsltDateFreeDuration (total);
2910
2911
87
    xmlXPathFreeNodeSet (ns);
2912
87
    if (user != NULL)
2913
0
  xmlFreeNodeList ((xmlNodePtr) user);
2914
2915
87
    if (ret == NULL)
2916
0
  xmlXPathReturnEmptyString (ctxt);
2917
87
    else
2918
87
  xmlXPathReturnString (ctxt, ret);
2919
87
}
2920
2921
/**
2922
 * exsltDateSeconds:
2923
 * @dateTime: a date/time string
2924
 *
2925
 * Implements the EXSLT - Dates and Times seconds() function:
2926
 *    number date:seconds(string?)
2927
 * The date:seconds function returns the number of seconds specified
2928
 * by the argument string. If no argument is given, then the current
2929
 * local date/time, as returned by exsltDateCurrent() is used as the
2930
 * default argument. If the date/time string is a xs:duration, then the
2931
 * years and months must be zero (or not present). Parsing a duration
2932
 * converts the fields to seconds. If the date/time string is not a
2933
 * duration (and not null), then the legal formats are:
2934
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
2935
 *  - xs:date     (CCYY-MM-DD)
2936
 *  - xs:gYearMonth (CCYY-MM)
2937
 *  - xs:gYear      (CCYY)
2938
 * In these cases the difference between the @dateTime and
2939
 * 1970-01-01T00:00:00Z is calculated and converted to seconds.
2940
 *
2941
 * Note that there was some confusion over whether "difference" meant
2942
 * that a dateTime of 1970-01-01T00:00:01Z should be a positive one or
2943
 * a negative one.  After correspondence with exslt.org, it was determined
2944
 * that the intent of the specification was to have it positive.  The
2945
 * coding was modified in July 2003 to reflect this.
2946
 *
2947
 * Returns seconds or Nan.
2948
 */
2949
static double
2950
exsltDateSeconds (const xmlChar *dateTime)
2951
147
{
2952
147
    exsltDateValPtr dt;
2953
147
    exsltDateDurValPtr dur = NULL;
2954
147
    double ret = xmlXPathNAN;
2955
2956
147
    if (dateTime == NULL) {
2957
30
  dt = exsltDateCurrent();
2958
30
  if (dt == NULL)
2959
0
      return xmlXPathNAN;
2960
117
    } else {
2961
117
        dt = exsltDateParse(dateTime);
2962
117
        if (dt == NULL)
2963
55
            dur = exsltDateParseDuration(dateTime);
2964
117
    }
2965
2966
147
    if ((dt != NULL) && (dt->type >= XS_GYEAR)) {
2967
84
        exsltDateValPtr y;
2968
84
        exsltDateDurValPtr diff;
2969
2970
        /*
2971
         * compute the difference between the given (or current) date
2972
         * and epoch date
2973
         */
2974
84
        y = exsltDateCreateDate(XS_DATETIME);
2975
84
        if (y != NULL) {
2976
84
            y->year = 1970;
2977
84
            y->mon  = 1;
2978
84
            y->day  = 1;
2979
84
            y->tz_flag = 1;
2980
2981
84
            diff = _exsltDateDifference(y, dt, 1);
2982
84
            if (diff != NULL) {
2983
79
                ret = (double)diff->day * SECS_PER_DAY + diff->sec;
2984
79
                exsltDateFreeDuration(diff);
2985
79
            }
2986
84
            exsltDateFreeDate(y);
2987
84
        }
2988
2989
84
    } else if ((dur != NULL) && (dur->mon == 0)) {
2990
0
        ret = (double)dur->day * SECS_PER_DAY + dur->sec;
2991
0
    }
2992
2993
147
    if (dt != NULL)
2994
92
        exsltDateFreeDate(dt);
2995
147
    if (dur != NULL)
2996
0
        exsltDateFreeDuration(dur);
2997
2998
147
    return ret;
2999
147
}
3000
3001
/**
3002
 * exsltDateDifference:
3003
 * @xstr: date/time string
3004
 * @ystr: date/time string
3005
 *
3006
 * Implements the date:difference (string,string) function which returns
3007
 * the duration between the first date and the second date. If the first
3008
 * date occurs before the second date, then the result is a positive
3009
 * duration; if it occurs after the second date, the result is a
3010
 * negative duration.  The two dates must both be right-truncated
3011
 * date/time strings in one of the formats defined in [XML Schema Part
3012
 * 2: Datatypes]. The date/time with the most specific format (i.e. the
3013
 * least truncation) is converted into the same format as the date with
3014
 * the least specific format (i.e. the most truncation). The permitted
3015
 * formats are as follows, from most specific to least specific:
3016
 *  - xs:dateTime (CCYY-MM-DDThh:mm:ss)
3017
 *  - xs:date (CCYY-MM-DD)
3018
 *  - xs:gYearMonth (CCYY-MM)
3019
 *  - xs:gYear (CCYY)
3020
 * If either of the arguments is not in one of these formats,
3021
 * date:difference returns the empty string ('').
3022
 * The difference between the date/times is returned as a string in the
3023
 * format defined for xs:duration in [3.2.6 duration] of [XML Schema
3024
 * Part 2: Datatypes].
3025
 * If the date/time string with the least specific format is in either
3026
 * xs:gYearMonth or xs:gYear format, then the number of days, hours,
3027
 * minutes and seconds in the duration string must be equal to zero.
3028
 * (The format of the string will be PnYnM.) The number of months
3029
 * specified in the duration must be less than 12.
3030
 * Otherwise, the number of years and months in the duration string
3031
 * must be equal to zero. (The format of the string will be
3032
 * PnDTnHnMnS.) The number of seconds specified in the duration string
3033
 * must be less than 60; the number of minutes must be less than 60;
3034
 * the number of hours must be less than 24.
3035
 *
3036
 * Returns duration string or NULL.
3037
 */
3038
static xmlChar *
3039
exsltDateDifference (const xmlChar *xstr, const xmlChar *ystr)
3040
373
{
3041
373
    exsltDateValPtr x, y;
3042
373
    exsltDateDurValPtr dur;
3043
373
    xmlChar *ret = NULL;
3044
3045
373
    if ((xstr == NULL) || (ystr == NULL))
3046
0
        return NULL;
3047
3048
373
    x = exsltDateParse(xstr);
3049
373
    if (x == NULL)
3050
125
        return NULL;
3051
3052
248
    y = exsltDateParse(ystr);
3053
248
    if (y == NULL) {
3054
122
        exsltDateFreeDate(x);
3055
122
        return NULL;
3056
122
    }
3057
3058
126
    if (((x->type < XS_GYEAR) || (x->type > XS_DATETIME)) ||
3059
126
        ((y->type < XS_GYEAR) || (y->type > XS_DATETIME)))  {
3060
18
  exsltDateFreeDate(x);
3061
18
  exsltDateFreeDate(y);
3062
18
        return NULL;
3063
18
    }
3064
3065
108
    dur = _exsltDateDifference(x, y, 0);
3066
3067
108
    exsltDateFreeDate(x);
3068
108
    exsltDateFreeDate(y);
3069
3070
108
    if (dur == NULL)
3071
0
        return NULL;
3072
3073
108
    ret = exsltDateFormatDuration(dur);
3074
108
    exsltDateFreeDuration(dur);
3075
3076
108
    return ret;
3077
108
}
3078
3079
/**
3080
 * exsltDateDuration:
3081
 * @number: a xmlChar string
3082
 *
3083
 * Implements the The date:duration function returns a duration string
3084
 * representing the number of seconds specified by the argument string.
3085
 * If no argument is given, then the result of calling date:seconds
3086
 * without any arguments is used as a default argument.
3087
 * The duration is returned as a string in the format defined for
3088
 * xs:duration in [3.2.6 duration] of [XML Schema Part 2: Datatypes].
3089
 * The number of years and months in the duration string must be equal
3090
 * to zero. (The format of the string will be PnDTnHnMnS.) The number
3091
 * of seconds specified in the duration string must be less than 60;
3092
 * the number of minutes must be less than 60; the number of hours must
3093
 * be less than 24.
3094
 * If the argument is Infinity, -Infinity or NaN, then date:duration
3095
 * returns an empty string ('').
3096
 *
3097
 * Returns duration string or NULL.
3098
 */
3099
static xmlChar *
3100
exsltDateDuration (const xmlChar *number)
3101
198
{
3102
198
    exsltDateDurValPtr dur;
3103
198
    double       secs, days;
3104
198
    xmlChar     *ret;
3105
3106
198
    if (number == NULL)
3107
17
        secs = exsltDateSeconds(number);
3108
181
    else
3109
181
        secs = xmlXPathCastStringToNumber(number);
3110
3111
198
    if (xmlXPathIsNaN(secs))
3112
79
        return NULL;
3113
3114
119
    days = floor(secs / SECS_PER_DAY);
3115
119
    if ((days <= (double)LONG_MIN) || (days >= (double)LONG_MAX))
3116
11
        return NULL;
3117
3118
108
    dur = exsltDateCreateDuration();
3119
108
    if (dur == NULL)
3120
0
        return NULL;
3121
3122
108
    dur->day = (long)days;
3123
108
    dur->sec = secs - days * SECS_PER_DAY;
3124
3125
108
    ret = exsltDateFormatDuration(dur);
3126
108
    exsltDateFreeDuration(dur);
3127
3128
108
    return ret;
3129
108
}
3130
3131
/****************************************************************
3132
 *                *
3133
 *    Wrappers for use by the XPath engine    *
3134
 *                *
3135
 ****************************************************************/
3136
3137
/**
3138
 * exsltDateDateTimeFunction:
3139
 * @ctxt: an XPath parser context
3140
 * @nargs : the number of arguments
3141
 *
3142
 * Wraps exsltDateDateTime() for use by the XPath engine.
3143
 */
3144
static void
3145
exsltDateDateTimeFunction (xmlXPathParserContextPtr ctxt, int nargs)
3146
35
{
3147
35
    xmlChar *ret;
3148
3149
35
    if (nargs != 0) {
3150
17
  xmlXPathSetArityError(ctxt);
3151
17
  return;
3152
17
    }
3153
3154
18
    ret = exsltDateDateTime();
3155
18
    if (ret == NULL)
3156
0
        xmlXPathReturnEmptyString(ctxt);
3157
18
    else
3158
18
        xmlXPathReturnString(ctxt, ret);
3159
18
}
3160
3161
/**
3162
 * exsltDateDateFunction:
3163
 * @ctxt: an XPath parser context
3164
 * @nargs : the number of arguments
3165
 *
3166
 * Wraps exsltDateDate() for use by the XPath engine.
3167
 */
3168
static void
3169
exsltDateDateFunction (xmlXPathParserContextPtr ctxt, int nargs)
3170
844
{
3171
844
    xmlChar *ret, *dt = NULL;
3172
3173
844
    if ((nargs < 0) || (nargs > 1)) {
3174
16
  xmlXPathSetArityError(ctxt);
3175
16
  return;
3176
16
    }
3177
828
    if (nargs == 1) {
3178
809
  dt = xmlXPathPopString(ctxt);
3179
809
  if (xmlXPathCheckError(ctxt)) {
3180
0
      xmlXPathSetTypeError(ctxt);
3181
0
      return;
3182
0
  }
3183
809
    }
3184
3185
828
    ret = exsltDateDate(dt);
3186
3187
828
    if (ret == NULL) {
3188
765
  xsltGenericDebug(xsltGenericDebugContext,
3189
765
       "{http://exslt.org/dates-and-times}date: "
3190
765
       "invalid date or format %s\n", dt);
3191
765
  xmlXPathReturnEmptyString(ctxt);
3192
765
    } else {
3193
63
  xmlXPathReturnString(ctxt, ret);
3194
63
    }
3195
3196
828
    if (dt != NULL)
3197
809
  xmlFree(dt);
3198
828
}
3199
3200
/**
3201
 * exsltDateTimeFunction:
3202
 * @ctxt: an XPath parser context
3203
 * @nargs : the number of arguments
3204
 *
3205
 * Wraps exsltDateTime() for use by the XPath engine.
3206
 */
3207
static void
3208
exsltDateTimeFunction (xmlXPathParserContextPtr ctxt, int nargs)
3209
221
{
3210
221
    xmlChar *ret, *dt = NULL;
3211
3212
221
    if ((nargs < 0) || (nargs > 1)) {
3213
13
  xmlXPathSetArityError(ctxt);
3214
13
  return;
3215
13
    }
3216
208
    if (nargs == 1) {
3217
193
  dt = xmlXPathPopString(ctxt);
3218
193
  if (xmlXPathCheckError(ctxt)) {
3219
0
      xmlXPathSetTypeError(ctxt);
3220
0
      return;
3221
0
  }
3222
193
    }
3223
3224
208
    ret = exsltDateTime(dt);
3225
3226
208
    if (ret == NULL) {
3227
162
  xsltGenericDebug(xsltGenericDebugContext,
3228
162
       "{http://exslt.org/dates-and-times}time: "
3229
162
       "invalid date or format %s\n", dt);
3230
162
  xmlXPathReturnEmptyString(ctxt);
3231
162
    } else {
3232
46
  xmlXPathReturnString(ctxt, ret);
3233
46
    }
3234
3235
208
    if (dt != NULL)
3236
193
  xmlFree(dt);
3237
208
}
3238
3239
/**
3240
 * exsltDateYearFunction:
3241
 * @ctxt: an XPath parser context
3242
 * @nargs : the number of arguments
3243
 *
3244
 * Wraps exsltDateYear() for use by the XPath engine.
3245
 */
3246
static void
3247
exsltDateYearFunction (xmlXPathParserContextPtr ctxt, int nargs)
3248
1.42k
{
3249
1.42k
    xmlChar *dt = NULL;
3250
1.42k
    double ret;
3251
3252
1.42k
    if ((nargs < 0) || (nargs > 1)) {
3253
14
  xmlXPathSetArityError(ctxt);
3254
14
  return;
3255
14
    }
3256
3257
1.40k
    if (nargs == 1) {
3258
1.39k
  dt = xmlXPathPopString(ctxt);
3259
1.39k
  if (xmlXPathCheckError(ctxt)) {
3260
0
      xmlXPathSetTypeError(ctxt);
3261
0
      return;
3262
0
  }
3263
1.39k
    }
3264
3265
1.40k
    ret = exsltDateYear(dt);
3266
3267
1.40k
    if (dt != NULL)
3268
1.39k
  xmlFree(dt);
3269
3270
1.40k
    xmlXPathReturnNumber(ctxt, ret);
3271
1.40k
}
3272
3273
/**
3274
 * exsltDateLeapYearFunction:
3275
 * @ctxt: an XPath parser context
3276
 * @nargs : the number of arguments
3277
 *
3278
 * Wraps exsltDateLeapYear() for use by the XPath engine.
3279
 */
3280
static void
3281
exsltDateLeapYearFunction (xmlXPathParserContextPtr ctxt, int nargs)
3282
160
{
3283
160
    xmlChar *dt = NULL;
3284
160
    xmlXPathObjectPtr ret;
3285
3286
160
    if ((nargs < 0) || (nargs > 1)) {
3287
15
  xmlXPathSetArityError(ctxt);
3288
15
  return;
3289
15
    }
3290
3291
145
    if (nargs == 1) {
3292
129
  dt = xmlXPathPopString(ctxt);
3293
129
  if (xmlXPathCheckError(ctxt)) {
3294
0
      xmlXPathSetTypeError(ctxt);
3295
0
      return;
3296
0
  }
3297
129
    }
3298
3299
145
    ret = exsltDateLeapYear(dt);
3300
3301
145
    if (dt != NULL)
3302
129
  xmlFree(dt);
3303
3304
145
    valuePush(ctxt, ret);
3305
145
}
3306
3307
#define X_IN_Y(x, y)            \
3308
static void             \
3309
exsltDate##x##In##y##Function (xmlXPathParserContextPtr ctxt, \
3310
2.11k
            int nargs) {     \
3311
2.11k
    xmlChar *dt = NULL;           \
3312
2.11k
    double ret;             \
3313
2.11k
                \
3314
2.11k
    if ((nargs < 0) || (nargs > 1)) {       \
3315
139
  xmlXPathSetArityError(ctxt);       \
3316
139
  return;             \
3317
139
    }                \
3318
2.11k
                \
3319
2.11k
    if (nargs == 1) {           \
3320
1.83k
  dt = xmlXPathPopString(ctxt);       \
3321
1.83k
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
1.83k
    }                \
3326
1.97k
                \
3327
1.97k
    ret = exsltDate##x##In##y(dt);        \
3328
1.97k
                \
3329
1.97k
    if (dt != NULL)           \
3330
1.97k
  xmlFree(dt);           \
3331
1.97k
                \
3332
1.97k
    xmlXPathReturnNumber(ctxt, ret);        \
3333
1.97k
}
date.c:exsltDateDayInMonthFunction
Line
Count
Source
3310
134
            int nargs) {     \
3311
134
    xmlChar *dt = NULL;           \
3312
134
    double ret;             \
3313
134
                \
3314
134
    if ((nargs < 0) || (nargs > 1)) {       \
3315
19
  xmlXPathSetArityError(ctxt);       \
3316
19
  return;             \
3317
19
    }                \
3318
134
                \
3319
134
    if (nargs == 1) {           \
3320
97
  dt = xmlXPathPopString(ctxt);       \
3321
97
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
97
    }                \
3326
115
                \
3327
115
    ret = exsltDate##x##In##y(dt);        \
3328
115
                \
3329
115
    if (dt != NULL)           \
3330
115
  xmlFree(dt);           \
3331
115
                \
3332
115
    xmlXPathReturnNumber(ctxt, ret);        \
3333
115
}
date.c:exsltDateDayInWeekFunction
Line
Count
Source
3310
65
            int nargs) {     \
3311
65
    xmlChar *dt = NULL;           \
3312
65
    double ret;             \
3313
65
                \
3314
65
    if ((nargs < 0) || (nargs > 1)) {       \
3315
13
  xmlXPathSetArityError(ctxt);       \
3316
13
  return;             \
3317
13
    }                \
3318
65
                \
3319
65
    if (nargs == 1) {           \
3320
38
  dt = xmlXPathPopString(ctxt);       \
3321
38
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
38
    }                \
3326
52
                \
3327
52
    ret = exsltDate##x##In##y(dt);        \
3328
52
                \
3329
52
    if (dt != NULL)           \
3330
52
  xmlFree(dt);           \
3331
52
                \
3332
52
    xmlXPathReturnNumber(ctxt, ret);        \
3333
52
}
date.c:exsltDateDayInYearFunction
Line
Count
Source
3310
132
            int nargs) {     \
3311
132
    xmlChar *dt = NULL;           \
3312
132
    double ret;             \
3313
132
                \
3314
132
    if ((nargs < 0) || (nargs > 1)) {       \
3315
24
  xmlXPathSetArityError(ctxt);       \
3316
24
  return;             \
3317
24
    }                \
3318
132
                \
3319
132
    if (nargs == 1) {           \
3320
95
  dt = xmlXPathPopString(ctxt);       \
3321
95
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
95
    }                \
3326
108
                \
3327
108
    ret = exsltDate##x##In##y(dt);        \
3328
108
                \
3329
108
    if (dt != NULL)           \
3330
108
  xmlFree(dt);           \
3331
108
                \
3332
108
    xmlXPathReturnNumber(ctxt, ret);        \
3333
108
}
date.c:exsltDateDayOfWeekInMonthFunction
Line
Count
Source
3310
89
            int nargs) {     \
3311
89
    xmlChar *dt = NULL;           \
3312
89
    double ret;             \
3313
89
                \
3314
89
    if ((nargs < 0) || (nargs > 1)) {       \
3315
1
  xmlXPathSetArityError(ctxt);       \
3316
1
  return;             \
3317
1
    }                \
3318
89
                \
3319
89
    if (nargs == 1) {           \
3320
75
  dt = xmlXPathPopString(ctxt);       \
3321
75
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
75
    }                \
3326
88
                \
3327
88
    ret = exsltDate##x##In##y(dt);        \
3328
88
                \
3329
88
    if (dt != NULL)           \
3330
88
  xmlFree(dt);           \
3331
88
                \
3332
88
    xmlXPathReturnNumber(ctxt, ret);        \
3333
88
}
date.c:exsltDateHourInDayFunction
Line
Count
Source
3310
144
            int nargs) {     \
3311
144
    xmlChar *dt = NULL;           \
3312
144
    double ret;             \
3313
144
                \
3314
144
    if ((nargs < 0) || (nargs > 1)) {       \
3315
18
  xmlXPathSetArityError(ctxt);       \
3316
18
  return;             \
3317
18
    }                \
3318
144
                \
3319
144
    if (nargs == 1) {           \
3320
111
  dt = xmlXPathPopString(ctxt);       \
3321
111
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
111
    }                \
3326
126
                \
3327
126
    ret = exsltDate##x##In##y(dt);        \
3328
126
                \
3329
126
    if (dt != NULL)           \
3330
126
  xmlFree(dt);           \
3331
126
                \
3332
126
    xmlXPathReturnNumber(ctxt, ret);        \
3333
126
}
date.c:exsltDateMinuteInHourFunction
Line
Count
Source
3310
126
            int nargs) {     \
3311
126
    xmlChar *dt = NULL;           \
3312
126
    double ret;             \
3313
126
                \
3314
126
    if ((nargs < 0) || (nargs > 1)) {       \
3315
14
  xmlXPathSetArityError(ctxt);       \
3316
14
  return;             \
3317
14
    }                \
3318
126
                \
3319
126
    if (nargs == 1) {           \
3320
98
  dt = xmlXPathPopString(ctxt);       \
3321
98
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
98
    }                \
3326
112
                \
3327
112
    ret = exsltDate##x##In##y(dt);        \
3328
112
                \
3329
112
    if (dt != NULL)           \
3330
112
  xmlFree(dt);           \
3331
112
                \
3332
112
    xmlXPathReturnNumber(ctxt, ret);        \
3333
112
}
date.c:exsltDateMonthInYearFunction
Line
Count
Source
3310
129
            int nargs) {     \
3311
129
    xmlChar *dt = NULL;           \
3312
129
    double ret;             \
3313
129
                \
3314
129
    if ((nargs < 0) || (nargs > 1)) {       \
3315
16
  xmlXPathSetArityError(ctxt);       \
3316
16
  return;             \
3317
16
    }                \
3318
129
                \
3319
129
    if (nargs == 1) {           \
3320
98
  dt = xmlXPathPopString(ctxt);       \
3321
98
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
98
    }                \
3326
113
                \
3327
113
    ret = exsltDate##x##In##y(dt);        \
3328
113
                \
3329
113
    if (dt != NULL)           \
3330
113
  xmlFree(dt);           \
3331
113
                \
3332
113
    xmlXPathReturnNumber(ctxt, ret);        \
3333
113
}
date.c:exsltDateSecondInMinuteFunction
Line
Count
Source
3310
130
            int nargs) {     \
3311
130
    xmlChar *dt = NULL;           \
3312
130
    double ret;             \
3313
130
                \
3314
130
    if ((nargs < 0) || (nargs > 1)) {       \
3315
1
  xmlXPathSetArityError(ctxt);       \
3316
1
  return;             \
3317
1
    }                \
3318
130
                \
3319
130
    if (nargs == 1) {           \
3320
112
  dt = xmlXPathPopString(ctxt);       \
3321
112
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
112
    }                \
3326
129
                \
3327
129
    ret = exsltDate##x##In##y(dt);        \
3328
129
                \
3329
129
    if (dt != NULL)           \
3330
129
  xmlFree(dt);           \
3331
129
                \
3332
129
    xmlXPathReturnNumber(ctxt, ret);        \
3333
129
}
date.c:exsltDateWeekInMonthFunction
Line
Count
Source
3310
125
            int nargs) {     \
3311
125
    xmlChar *dt = NULL;           \
3312
125
    double ret;             \
3313
125
                \
3314
125
    if ((nargs < 0) || (nargs > 1)) {       \
3315
16
  xmlXPathSetArityError(ctxt);       \
3316
16
  return;             \
3317
16
    }                \
3318
125
                \
3319
125
    if (nargs == 1) {           \
3320
97
  dt = xmlXPathPopString(ctxt);       \
3321
97
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
97
    }                \
3326
109
                \
3327
109
    ret = exsltDate##x##In##y(dt);        \
3328
109
                \
3329
109
    if (dt != NULL)           \
3330
109
  xmlFree(dt);           \
3331
109
                \
3332
109
    xmlXPathReturnNumber(ctxt, ret);        \
3333
109
}
date.c:exsltDateWeekInYearFunction
Line
Count
Source
3310
1.04k
            int nargs) {     \
3311
1.04k
    xmlChar *dt = NULL;           \
3312
1.04k
    double ret;             \
3313
1.04k
                \
3314
1.04k
    if ((nargs < 0) || (nargs > 1)) {       \
3315
17
  xmlXPathSetArityError(ctxt);       \
3316
17
  return;             \
3317
17
    }                \
3318
1.04k
                \
3319
1.04k
    if (nargs == 1) {           \
3320
1.01k
  dt = xmlXPathPopString(ctxt);       \
3321
1.01k
  if (xmlXPathCheckError(ctxt)) {       \
3322
0
      xmlXPathSetTypeError(ctxt);       \
3323
0
      return;           \
3324
0
  }              \
3325
1.01k
    }                \
3326
1.02k
                \
3327
1.02k
    ret = exsltDate##x##In##y(dt);        \
3328
1.02k
                \
3329
1.02k
    if (dt != NULL)           \
3330
1.02k
  xmlFree(dt);           \
3331
1.02k
                \
3332
1.02k
    xmlXPathReturnNumber(ctxt, ret);        \
3333
1.02k
}
3334
3335
/**
3336
 * exsltDateMonthInYearFunction:
3337
 * @ctxt: an XPath parser context
3338
 * @nargs : the number of arguments
3339
 *
3340
 * Wraps exsltDateMonthInYear() for use by the XPath engine.
3341
 */
3342
X_IN_Y(Month,Year)
3343
3344
/**
3345
 * exsltDateMonthNameFunction:
3346
 * @ctxt: an XPath parser context
3347
 * @nargs : the number of arguments
3348
 *
3349
 * Wraps exsltDateMonthName() for use by the XPath engine.
3350
 */
3351
static void
3352
exsltDateMonthNameFunction (xmlXPathParserContextPtr ctxt, int nargs)
3353
164
{
3354
164
    xmlChar *dt = NULL;
3355
164
    const xmlChar *ret;
3356
3357
164
    if ((nargs < 0) || (nargs > 1)) {
3358
14
  xmlXPathSetArityError(ctxt);
3359
14
  return;
3360
14
    }
3361
3362
150
    if (nargs == 1) {
3363
136
  dt = xmlXPathPopString(ctxt);
3364
136
  if (xmlXPathCheckError(ctxt)) {
3365
0
      xmlXPathSetTypeError(ctxt);
3366
0
      return;
3367
0
  }
3368
136
    }
3369
3370
150
    ret = exsltDateMonthName(dt);
3371
3372
150
    if (dt != NULL)
3373
136
  xmlFree(dt);
3374
3375
150
    if (ret == NULL)
3376
0
  xmlXPathReturnEmptyString(ctxt);
3377
150
    else
3378
150
  xmlXPathReturnString(ctxt, xmlStrdup(ret));
3379
150
}
3380
3381
/**
3382
 * exsltDateMonthAbbreviationFunction:
3383
 * @ctxt: an XPath parser context
3384
 * @nargs : the number of arguments
3385
 *
3386
 * Wraps exsltDateMonthAbbreviation() for use by the XPath engine.
3387
 */
3388
static void
3389
exsltDateMonthAbbreviationFunction (xmlXPathParserContextPtr ctxt, int nargs)
3390
99
{
3391
99
    xmlChar *dt = NULL;
3392
99
    const xmlChar *ret;
3393
3394
99
    if ((nargs < 0) || (nargs > 1)) {
3395
16
  xmlXPathSetArityError(ctxt);
3396
16
  return;
3397
16
    }
3398
3399
83
    if (nargs == 1) {
3400
70
  dt = xmlXPathPopString(ctxt);
3401
70
  if (xmlXPathCheckError(ctxt)) {
3402
0
      xmlXPathSetTypeError(ctxt);
3403
0
      return;
3404
0
  }
3405
70
    }
3406
3407
83
    ret = exsltDateMonthAbbreviation(dt);
3408
3409
83
    if (dt != NULL)
3410
70
  xmlFree(dt);
3411
3412
83
    if (ret == NULL)
3413
0
  xmlXPathReturnEmptyString(ctxt);
3414
83
    else
3415
83
  xmlXPathReturnString(ctxt, xmlStrdup(ret));
3416
83
}
3417
3418
/**
3419
 * exsltDateWeekInYearFunction:
3420
 * @ctxt: an XPath parser context
3421
 * @nargs : the number of arguments
3422
 *
3423
 * Wraps exsltDateWeekInYear() for use by the XPath engine.
3424
 */
3425
X_IN_Y(Week,Year)
3426
3427
/**
3428
 * exsltDateWeekInMonthFunction:
3429
 * @ctxt: an XPath parser context
3430
 * @nargs : the number of arguments
3431
 *
3432
 * Wraps exsltDateWeekInMonthYear() for use by the XPath engine.
3433
 */
3434
X_IN_Y(Week,Month)
3435
3436
/**
3437
 * exsltDateDayInYearFunction:
3438
 * @ctxt: an XPath parser context
3439
 * @nargs : the number of arguments
3440
 *
3441
 * Wraps exsltDateDayInYear() for use by the XPath engine.
3442
 */
3443
X_IN_Y(Day,Year)
3444
3445
/**
3446
 * exsltDateDayInMonthFunction:
3447
 * @ctxt: an XPath parser context
3448
 * @nargs : the number of arguments
3449
 *
3450
 * Wraps exsltDateDayInMonth() for use by the XPath engine.
3451
 */
3452
X_IN_Y(Day,Month)
3453
3454
/**
3455
 * exsltDateDayOfWeekInMonthFunction:
3456
 * @ctxt: an XPath parser context
3457
 * @nargs : the number of arguments
3458
 *
3459
 * Wraps exsltDayOfWeekInMonth() for use by the XPath engine.
3460
 */
3461
X_IN_Y(DayOfWeek,Month)
3462
3463
/**
3464
 * exsltDateDayInWeekFunction:
3465
 * @ctxt: an XPath parser context
3466
 * @nargs : the number of arguments
3467
 *
3468
 * Wraps exsltDateDayInWeek() for use by the XPath engine.
3469
 */
3470
X_IN_Y(Day,Week)
3471
3472
/**
3473
 * exsltDateDayNameFunction:
3474
 * @ctxt: an XPath parser context
3475
 * @nargs : the number of arguments
3476
 *
3477
 * Wraps exsltDateDayName() for use by the XPath engine.
3478
 */
3479
static void
3480
exsltDateDayNameFunction (xmlXPathParserContextPtr ctxt, int nargs)
3481
262
{
3482
262
    xmlChar *dt = NULL;
3483
262
    const xmlChar *ret;
3484
3485
262
    if ((nargs < 0) || (nargs > 1)) {
3486
15
  xmlXPathSetArityError(ctxt);
3487
15
  return;
3488
15
    }
3489
3490
247
    if (nargs == 1) {
3491
232
  dt = xmlXPathPopString(ctxt);
3492
232
  if (xmlXPathCheckError(ctxt)) {
3493
0
      xmlXPathSetTypeError(ctxt);
3494
0
      return;
3495
0
  }
3496
232
    }
3497
3498
247
    ret = exsltDateDayName(dt);
3499
3500
247
    if (dt != NULL)
3501
232
  xmlFree(dt);
3502
3503
247
    if (ret == NULL)
3504
0
  xmlXPathReturnEmptyString(ctxt);
3505
247
    else
3506
247
  xmlXPathReturnString(ctxt, xmlStrdup(ret));
3507
247
}
3508
3509
/**
3510
 * exsltDateMonthDayFunction:
3511
 * @ctxt: an XPath parser context
3512
 * @nargs : the number of arguments
3513
 *
3514
 * Wraps exsltDateDayAbbreviation() for use by the XPath engine.
3515
 */
3516
static void
3517
exsltDateDayAbbreviationFunction (xmlXPathParserContextPtr ctxt, int nargs)
3518
72
{
3519
72
    xmlChar *dt = NULL;
3520
72
    const xmlChar *ret;
3521
3522
72
    if ((nargs < 0) || (nargs > 1)) {
3523
15
  xmlXPathSetArityError(ctxt);
3524
15
  return;
3525
15
    }
3526
3527
57
    if (nargs == 1) {
3528
40
  dt = xmlXPathPopString(ctxt);
3529
40
  if (xmlXPathCheckError(ctxt)) {
3530
0
      xmlXPathSetTypeError(ctxt);
3531
0
      return;
3532
0
  }
3533
40
    }
3534
3535
57
    ret = exsltDateDayAbbreviation(dt);
3536
3537
57
    if (dt != NULL)
3538
40
  xmlFree(dt);
3539
3540
57
    if (ret == NULL)
3541
0
  xmlXPathReturnEmptyString(ctxt);
3542
57
    else
3543
57
  xmlXPathReturnString(ctxt, xmlStrdup(ret));
3544
57
}
3545
3546
3547
/**
3548
 * exsltDateHourInDayFunction:
3549
 * @ctxt: an XPath parser context
3550
 * @nargs : the number of arguments
3551
 *
3552
 * Wraps exsltDateHourInDay() for use by the XPath engine.
3553
 */
3554
X_IN_Y(Hour,Day)
3555
3556
/**
3557
 * exsltDateMinuteInHourFunction:
3558
 * @ctxt: an XPath parser context
3559
 * @nargs : the number of arguments
3560
 *
3561
 * Wraps exsltDateMinuteInHour() for use by the XPath engine.
3562
 */
3563
X_IN_Y(Minute,Hour)
3564
3565
/**
3566
 * exsltDateSecondInMinuteFunction:
3567
 * @ctxt: an XPath parser context
3568
 * @nargs : the number of arguments
3569
 *
3570
 * Wraps exsltDateSecondInMinute() for use by the XPath engine.
3571
 */
3572
X_IN_Y(Second,Minute)
3573
3574
/**
3575
 * exsltDateSecondsFunction:
3576
 * @ctxt: an XPath parser context
3577
 * @nargs : the number of arguments
3578
 *
3579
 * Wraps exsltDateSeconds() for use by the XPath engine.
3580
 */
3581
static void
3582
exsltDateSecondsFunction (xmlXPathParserContextPtr ctxt, int nargs)
3583
143
{
3584
143
    xmlChar *str = NULL;
3585
143
    double   ret;
3586
3587
143
    if (nargs > 1) {
3588
13
  xmlXPathSetArityError(ctxt);
3589
13
  return;
3590
13
    }
3591
3592
130
    if (nargs == 1) {
3593
117
  str = xmlXPathPopString(ctxt);
3594
117
  if (xmlXPathCheckError(ctxt)) {
3595
0
      xmlXPathSetTypeError(ctxt);
3596
0
      return;
3597
0
  }
3598
117
    }
3599
3600
130
    ret = exsltDateSeconds(str);
3601
130
    if (str != NULL)
3602
117
  xmlFree(str);
3603
3604
130
    xmlXPathReturnNumber(ctxt, ret);
3605
130
}
3606
3607
/**
3608
 * exsltDateAddFunction:
3609
 * @ctxt:  an XPath parser context
3610
 * @nargs:  the number of arguments
3611
 *
3612
 * Wraps exsltDateAdd() for use by the XPath processor.
3613
 */
3614
static void
3615
exsltDateAddFunction (xmlXPathParserContextPtr ctxt, int nargs)
3616
8.18k
{
3617
8.18k
    xmlChar *ret, *xstr, *ystr;
3618
3619
8.18k
    if (nargs != 2) {
3620
41
  xmlXPathSetArityError(ctxt);
3621
41
  return;
3622
41
    }
3623
8.14k
    ystr = xmlXPathPopString(ctxt);
3624
8.14k
    if (xmlXPathCheckError(ctxt))
3625
0
  return;
3626
3627
8.14k
    xstr = xmlXPathPopString(ctxt);
3628
8.14k
    if (xmlXPathCheckError(ctxt)) {
3629
0
        xmlFree(ystr);
3630
0
  return;
3631
0
    }
3632
3633
8.14k
    ret = exsltDateAdd(xstr, ystr);
3634
3635
8.14k
    xmlFree(ystr);
3636
8.14k
    xmlFree(xstr);
3637
3638
8.14k
    if (ret == NULL)
3639
7.87k
        xmlXPathReturnEmptyString(ctxt);
3640
269
    else
3641
269
  xmlXPathReturnString(ctxt, ret);
3642
8.14k
}
3643
3644
/**
3645
 * exsltDateAddDurationFunction:
3646
 * @ctxt:  an XPath parser context
3647
 * @nargs:  the number of arguments
3648
 *
3649
 * Wraps exsltDateAddDuration() for use by the XPath processor.
3650
 */
3651
static void
3652
exsltDateAddDurationFunction (xmlXPathParserContextPtr ctxt, int nargs)
3653
224
{
3654
224
    xmlChar *ret, *xstr, *ystr;
3655
3656
224
    if (nargs != 2) {
3657
20
  xmlXPathSetArityError(ctxt);
3658
20
  return;
3659
20
    }
3660
204
    ystr = xmlXPathPopString(ctxt);
3661
204
    if (xmlXPathCheckError(ctxt))
3662
0
  return;
3663
3664
204
    xstr = xmlXPathPopString(ctxt);
3665
204
    if (xmlXPathCheckError(ctxt)) {
3666
0
        xmlFree(ystr);
3667
0
  return;
3668
0
    }
3669
3670
204
    ret = exsltDateAddDuration(xstr, ystr);
3671
3672
204
    xmlFree(ystr);
3673
204
    xmlFree(xstr);
3674
3675
204
    if (ret == NULL)
3676
137
        xmlXPathReturnEmptyString(ctxt);
3677
67
    else
3678
67
  xmlXPathReturnString(ctxt, ret);
3679
204
}
3680
3681
/**
3682
 * exsltDateDifferenceFunction:
3683
 * @ctxt:  an XPath parser context
3684
 * @nargs:  the number of arguments
3685
 *
3686
 * Wraps exsltDateDifference() for use by the XPath processor.
3687
 */
3688
static void
3689
exsltDateDifferenceFunction (xmlXPathParserContextPtr ctxt, int nargs)
3690
405
{
3691
405
    xmlChar *ret, *xstr, *ystr;
3692
3693
405
    if (nargs != 2) {
3694
32
  xmlXPathSetArityError(ctxt);
3695
32
  return;
3696
32
    }
3697
373
    ystr = xmlXPathPopString(ctxt);
3698
373
    if (xmlXPathCheckError(ctxt))
3699
0
  return;
3700
3701
373
    xstr = xmlXPathPopString(ctxt);
3702
373
    if (xmlXPathCheckError(ctxt)) {
3703
0
        xmlFree(ystr);
3704
0
  return;
3705
0
    }
3706
3707
373
    ret = exsltDateDifference(xstr, ystr);
3708
3709
373
    xmlFree(ystr);
3710
373
    xmlFree(xstr);
3711
3712
373
    if (ret == NULL)
3713
265
        xmlXPathReturnEmptyString(ctxt);
3714
108
    else
3715
108
  xmlXPathReturnString(ctxt, ret);
3716
373
}
3717
3718
/**
3719
 * exsltDateDurationFunction:
3720
 * @ctxt: an XPath parser context
3721
 * @nargs : the number of arguments
3722
 *
3723
 * Wraps exsltDateDuration() for use by the XPath engine
3724
 */
3725
static void
3726
exsltDateDurationFunction (xmlXPathParserContextPtr ctxt, int nargs)
3727
210
{
3728
210
    xmlChar *ret;
3729
210
    xmlChar *number = NULL;
3730
3731
210
    if ((nargs < 0) || (nargs > 1)) {
3732
12
  xmlXPathSetArityError(ctxt);
3733
12
  return;
3734
12
    }
3735
3736
198
    if (nargs == 1) {
3737
181
  number = xmlXPathPopString(ctxt);
3738
181
  if (xmlXPathCheckError(ctxt)) {
3739
0
      xmlXPathSetTypeError(ctxt);
3740
0
      return;
3741
0
  }
3742
181
    }
3743
3744
198
    ret = exsltDateDuration(number);
3745
3746
198
    if (number != NULL)
3747
181
  xmlFree(number);
3748
3749
198
    if (ret == NULL)
3750
90
  xmlXPathReturnEmptyString(ctxt);
3751
108
    else
3752
108
  xmlXPathReturnString(ctxt, ret);
3753
198
}
3754
3755
/**
3756
 * exsltDateRegister:
3757
 *
3758
 * Registers the EXSLT - Dates and Times module
3759
 */
3760
void
3761
exsltDateRegister (void)
3762
2.97k
{
3763
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "add",
3764
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3765
2.97k
           exsltDateAddFunction);
3766
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "add-duration",
3767
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3768
2.97k
           exsltDateAddDurationFunction);
3769
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "date",
3770
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3771
2.97k
           exsltDateDateFunction);
3772
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "date-time",
3773
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3774
2.97k
           exsltDateDateTimeFunction);
3775
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "day-abbreviation",
3776
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3777
2.97k
           exsltDateDayAbbreviationFunction);
3778
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "day-in-month",
3779
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3780
2.97k
           exsltDateDayInMonthFunction);
3781
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "day-in-week",
3782
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3783
2.97k
           exsltDateDayInWeekFunction);
3784
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "day-in-year",
3785
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3786
2.97k
           exsltDateDayInYearFunction);
3787
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "day-name",
3788
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3789
2.97k
           exsltDateDayNameFunction);
3790
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "day-of-week-in-month",
3791
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3792
2.97k
           exsltDateDayOfWeekInMonthFunction);
3793
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "difference",
3794
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3795
2.97k
           exsltDateDifferenceFunction);
3796
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "duration",
3797
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3798
2.97k
           exsltDateDurationFunction);
3799
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "hour-in-day",
3800
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3801
2.97k
           exsltDateHourInDayFunction);
3802
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "leap-year",
3803
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3804
2.97k
           exsltDateLeapYearFunction);
3805
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "minute-in-hour",
3806
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3807
2.97k
           exsltDateMinuteInHourFunction);
3808
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "month-abbreviation",
3809
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3810
2.97k
           exsltDateMonthAbbreviationFunction);
3811
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "month-in-year",
3812
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3813
2.97k
           exsltDateMonthInYearFunction);
3814
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "month-name",
3815
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3816
2.97k
           exsltDateMonthNameFunction);
3817
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "second-in-minute",
3818
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3819
2.97k
           exsltDateSecondInMinuteFunction);
3820
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "seconds",
3821
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3822
2.97k
           exsltDateSecondsFunction);
3823
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "sum",
3824
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3825
2.97k
           exsltDateSumFunction);
3826
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "time",
3827
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3828
2.97k
           exsltDateTimeFunction);
3829
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "week-in-month",
3830
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3831
2.97k
           exsltDateWeekInMonthFunction);
3832
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "week-in-year",
3833
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3834
2.97k
           exsltDateWeekInYearFunction);
3835
2.97k
    xsltRegisterExtModuleFunction ((const xmlChar *) "year",
3836
2.97k
           (const xmlChar *) EXSLT_DATE_NAMESPACE,
3837
2.97k
           exsltDateYearFunction);
3838
2.97k
}
3839
3840
/**
3841
 * exsltDateXpathCtxtRegister:
3842
 *
3843
 * Registers the EXSLT - Dates and Times module for use outside XSLT
3844
 */
3845
int
3846
exsltDateXpathCtxtRegister (xmlXPathContextPtr ctxt, const xmlChar *prefix)
3847
0
{
3848
0
    if (ctxt
3849
0
        && prefix
3850
0
        && !xmlXPathRegisterNs(ctxt,
3851
0
                               prefix,
3852
0
                               (const xmlChar *) EXSLT_DATE_NAMESPACE)
3853
0
        && !xmlXPathRegisterFuncNS(ctxt,
3854
0
                                   (const xmlChar *) "add",
3855
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3856
0
                                   exsltDateAddFunction)
3857
0
        && !xmlXPathRegisterFuncNS(ctxt,
3858
0
                                   (const xmlChar *) "add-duration",
3859
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3860
0
                                   exsltDateAddDurationFunction)
3861
0
        && !xmlXPathRegisterFuncNS(ctxt,
3862
0
                                   (const xmlChar *) "date",
3863
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3864
0
                                   exsltDateDateFunction)
3865
0
        && !xmlXPathRegisterFuncNS(ctxt,
3866
0
                                   (const xmlChar *) "date-time",
3867
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3868
0
                                   exsltDateDateTimeFunction)
3869
0
        && !xmlXPathRegisterFuncNS(ctxt,
3870
0
                                   (const xmlChar *) "day-abbreviation",
3871
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3872
0
                                   exsltDateDayAbbreviationFunction)
3873
0
        && !xmlXPathRegisterFuncNS(ctxt,
3874
0
                                   (const xmlChar *) "day-in-month",
3875
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3876
0
                                   exsltDateDayInMonthFunction)
3877
0
        && !xmlXPathRegisterFuncNS(ctxt,
3878
0
                                   (const xmlChar *) "day-in-week",
3879
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3880
0
                                   exsltDateDayInWeekFunction)
3881
0
        && !xmlXPathRegisterFuncNS(ctxt,
3882
0
                                   (const xmlChar *) "day-in-year",
3883
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3884
0
                                   exsltDateDayInYearFunction)
3885
0
        && !xmlXPathRegisterFuncNS(ctxt,
3886
0
                                   (const xmlChar *) "day-name",
3887
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3888
0
                                   exsltDateDayNameFunction)
3889
0
        && !xmlXPathRegisterFuncNS(ctxt,
3890
0
                                   (const xmlChar *) "day-of-week-in-month",
3891
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3892
0
                                   exsltDateDayOfWeekInMonthFunction)
3893
0
        && !xmlXPathRegisterFuncNS(ctxt,
3894
0
                                   (const xmlChar *) "difference",
3895
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3896
0
                                   exsltDateDifferenceFunction)
3897
0
        && !xmlXPathRegisterFuncNS(ctxt,
3898
0
                                   (const xmlChar *) "duration",
3899
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3900
0
                                   exsltDateDurationFunction)
3901
0
        && !xmlXPathRegisterFuncNS(ctxt,
3902
0
                                   (const xmlChar *) "hour-in-day",
3903
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3904
0
                                   exsltDateHourInDayFunction)
3905
0
        && !xmlXPathRegisterFuncNS(ctxt,
3906
0
                                   (const xmlChar *) "leap-year",
3907
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3908
0
                                   exsltDateLeapYearFunction)
3909
0
        && !xmlXPathRegisterFuncNS(ctxt,
3910
0
                                   (const xmlChar *) "minute-in-hour",
3911
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3912
0
                                   exsltDateMinuteInHourFunction)
3913
0
        && !xmlXPathRegisterFuncNS(ctxt,
3914
0
                                   (const xmlChar *) "month-abbreviation",
3915
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3916
0
                                   exsltDateMonthAbbreviationFunction)
3917
0
        && !xmlXPathRegisterFuncNS(ctxt,
3918
0
                                   (const xmlChar *) "month-in-year",
3919
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3920
0
                                   exsltDateMonthInYearFunction)
3921
0
        && !xmlXPathRegisterFuncNS(ctxt,
3922
0
                                   (const xmlChar *) "month-name",
3923
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3924
0
                                   exsltDateMonthNameFunction)
3925
0
        && !xmlXPathRegisterFuncNS(ctxt,
3926
0
                                   (const xmlChar *) "second-in-minute",
3927
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3928
0
                                   exsltDateSecondInMinuteFunction)
3929
0
        && !xmlXPathRegisterFuncNS(ctxt,
3930
0
                                   (const xmlChar *) "seconds",
3931
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3932
0
                                   exsltDateSecondsFunction)
3933
0
        && !xmlXPathRegisterFuncNS(ctxt,
3934
0
                                   (const xmlChar *) "sum",
3935
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3936
0
                                   exsltDateSumFunction)
3937
0
        && !xmlXPathRegisterFuncNS(ctxt,
3938
0
                                   (const xmlChar *) "time",
3939
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3940
0
                                   exsltDateTimeFunction)
3941
0
        && !xmlXPathRegisterFuncNS(ctxt,
3942
0
                                   (const xmlChar *) "week-in-month",
3943
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3944
0
                                   exsltDateWeekInMonthFunction)
3945
0
        && !xmlXPathRegisterFuncNS(ctxt,
3946
0
                                   (const xmlChar *) "week-in-year",
3947
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3948
0
                                   exsltDateWeekInYearFunction)
3949
0
        && !xmlXPathRegisterFuncNS(ctxt,
3950
0
                                   (const xmlChar *) "year",
3951
0
                                   (const xmlChar *) EXSLT_DATE_NAMESPACE,
3952
0
                                   exsltDateYearFunction)) {
3953
0
        return 0;
3954
0
    }
3955
0
    return -1;
3956
0
}