Coverage Report

Created: 2023-03-02 15:27

/src/libxslt/libexslt/math.c
Line
Count
Source (jump to first uncovered line)
1
#define IN_LIBEXSLT
2
#include "libexslt/libexslt.h"
3
4
#include <libxml/tree.h>
5
#include <libxml/xpath.h>
6
#include <libxml/xpathInternals.h>
7
8
#include <libxslt/xsltutils.h>
9
#include <libxslt/xsltInternals.h>
10
#include <libxslt/extensions.h>
11
12
#include <math.h>
13
#include <stdlib.h>
14
15
#include "exslt.h"
16
17
/**
18
 * exsltMathMin:
19
 * @ns:  a node-set
20
 *
21
 * Implements the EXSLT - Math min() function:
22
 *    number math:min (node-set)
23
 *
24
 * Returns the minimum value of the nodes passed as the argument, or
25
 *         xmlXPathNAN if @ns is NULL or empty or if one of the nodes
26
 *         turns into NaN.
27
 */
28
static double
29
1.03k
exsltMathMin (xmlNodeSetPtr ns) {
30
1.03k
    double ret, cur;
31
1.03k
    int i;
32
33
1.03k
    if ((ns == NULL) || (ns->nodeNr == 0))
34
277
  return(xmlXPathNAN);
35
757
    ret = xmlXPathCastNodeToNumber(ns->nodeTab[0]);
36
757
    if (xmlXPathIsNaN(ret))
37
115
  return(xmlXPathNAN);
38
5.46k
    for (i = 1; i < ns->nodeNr; i++) {
39
5.25k
  cur = xmlXPathCastNodeToNumber(ns->nodeTab[i]);
40
5.25k
  if (xmlXPathIsNaN(cur))
41
431
      return(xmlXPathNAN);
42
4.82k
  if (cur < ret)
43
621
      ret = cur;
44
4.82k
    }
45
211
    return(ret);
46
642
}
47
48
/**
49
 * exsltMathMinFunction:
50
 * @ctxt:  an XPath parser context
51
 * @nargs:  the number of arguments
52
 *
53
 * Wraps #exsltMathMin for use by the XPath processor.
54
 */
55
static void
56
1.08k
exsltMathMinFunction (xmlXPathParserContextPtr ctxt, int nargs) {
57
1.08k
    xmlNodeSetPtr ns;
58
1.08k
    double ret;
59
1.08k
    void *user = NULL;
60
61
1.08k
    if (nargs != 1) {
62
16
  xsltGenericError(xsltGenericErrorContext,
63
16
       "math:min: invalid number of arguments\n");
64
16
  ctxt->error = XPATH_INVALID_ARITY;
65
16
  return;
66
16
    }
67
    /* We need to delay the freeing of value->user */
68
1.06k
    if ((ctxt->value != NULL) && (ctxt->value->boolval != 0)) {
69
22
        user = ctxt->value->user;
70
22
  ctxt->value->boolval = 0;
71
22
  ctxt->value->user = NULL;
72
22
    }
73
1.06k
    ns = xmlXPathPopNodeSet(ctxt);
74
1.06k
    if (xmlXPathCheckError(ctxt))
75
30
  return;
76
77
1.03k
    ret = exsltMathMin(ns);
78
79
1.03k
    xmlXPathFreeNodeSet(ns);
80
1.03k
    if (user != NULL)
81
0
        xmlFreeNodeList((xmlNodePtr)user);
82
83
1.03k
    xmlXPathReturnNumber(ctxt, ret);
84
1.03k
}
85
86
/**
87
 * exsltMathMax:
88
 * @ns:  a node-set
89
 *
90
 * Implements the EXSLT - Math max() function:
91
 *    number math:max (node-set)
92
 *
93
 * Returns the maximum value of the nodes passed as arguments, or
94
 *         xmlXPathNAN if @ns is NULL or empty or if one of the nodes
95
 *         turns into NaN.
96
 */
97
static double
98
915
exsltMathMax (xmlNodeSetPtr ns) {
99
915
    double ret, cur;
100
915
    int i;
101
102
915
    if ((ns == NULL) || (ns->nodeNr == 0))
103
352
  return(xmlXPathNAN);
104
563
    ret = xmlXPathCastNodeToNumber(ns->nodeTab[0]);
105
563
    if (xmlXPathIsNaN(ret))
106
218
  return(xmlXPathNAN);
107
5.29k
    for (i = 1; i < ns->nodeNr; i++) {
108
5.16k
  cur = xmlXPathCastNodeToNumber(ns->nodeTab[i]);
109
5.16k
  if (xmlXPathIsNaN(cur))
110
208
      return(xmlXPathNAN);
111
4.95k
  if (cur > ret)
112
93
      ret = cur;
113
4.95k
    }
114
137
    return(ret);
115
345
}
116
117
/**
118
 * exsltMathMaxFunction:
119
 * @ctxt:  an XPath parser context
120
 * @nargs:  the number of arguments
121
 *
122
 * Wraps #exsltMathMax for use by the XPath processor.
123
 */
124
static void
125
1.00k
exsltMathMaxFunction (xmlXPathParserContextPtr ctxt, int nargs) {
126
1.00k
    xmlNodeSetPtr ns;
127
1.00k
    double ret;
128
1.00k
    void *user = NULL;
129
130
1.00k
    if (nargs != 1) {
131
39
  xmlXPathSetArityError(ctxt);
132
39
  return;
133
39
    }
134
135
    /* We need to delay the freeing of value->user */
136
968
    if ((ctxt->value != NULL) && (ctxt->value->boolval != 0)) {
137
20
  user = ctxt->value->user;
138
20
  ctxt->value->boolval = 0;
139
20
  ctxt->value->user = 0;
140
20
    }
141
968
    ns = xmlXPathPopNodeSet(ctxt);
142
968
    if (xmlXPathCheckError(ctxt))
143
53
  return;
144
145
915
    ret = exsltMathMax(ns);
146
147
915
    xmlXPathFreeNodeSet(ns);
148
149
915
    if (user != NULL)
150
0
        xmlFreeNodeList((xmlNodePtr)user);
151
915
    xmlXPathReturnNumber(ctxt, ret);
152
915
}
153
154
/**
155
 * exsltMathHighest:
156
 * @ns:  a node-set
157
 *
158
 * Implements the EXSLT - Math highest() function:
159
 *    node-set math:highest (node-set)
160
 *
161
 * Returns the nodes in the node-set whose value is the maximum value
162
 *         for the node-set.
163
 */
164
static xmlNodeSetPtr
165
3.60k
exsltMathHighest (xmlNodeSetPtr ns) {
166
3.60k
    xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
167
3.60k
    double max, cur;
168
3.60k
    int i;
169
170
3.60k
    if ((ns == NULL) || (ns->nodeNr == 0))
171
308
  return(ret);
172
173
3.29k
    max = xmlXPathCastNodeToNumber(ns->nodeTab[0]);
174
3.29k
    if (xmlXPathIsNaN(max))
175
1.83k
  return(ret);
176
1.46k
    else
177
1.46k
  xmlXPathNodeSetAddUnique(ret, ns->nodeTab[0]);
178
179
67.6k
    for (i = 1; i < ns->nodeNr; i++) {
180
67.0k
  cur = xmlXPathCastNodeToNumber(ns->nodeTab[i]);
181
67.0k
  if (xmlXPathIsNaN(cur)) {
182
863
      xmlXPathEmptyNodeSet(ret);
183
863
      return(ret);
184
863
  }
185
66.1k
  if (cur < max)
186
31.2k
      continue;
187
34.9k
  if (cur > max) {
188
1.49k
      max = cur;
189
1.49k
      xmlXPathEmptyNodeSet(ret);
190
1.49k
      xmlXPathNodeSetAddUnique(ret, ns->nodeTab[i]);
191
1.49k
      continue;
192
1.49k
  }
193
33.4k
  xmlXPathNodeSetAddUnique(ret, ns->nodeTab[i]);
194
33.4k
    }
195
598
    return(ret);
196
1.46k
}
197
198
/**
199
 * exsltMathHighestFunction:
200
 * @ctxt:  an XPath parser context
201
 * @nargs:  the number of arguments
202
 *
203
 * Wraps #exsltMathHighest for use by the XPath processor
204
 */
205
static void
206
3.74k
exsltMathHighestFunction (xmlXPathParserContextPtr ctxt, int nargs) {
207
3.74k
    xmlNodeSetPtr ns, ret;
208
3.74k
    void *user = NULL;
209
210
3.74k
    if (nargs != 1) {
211
88
  xmlXPathSetArityError(ctxt);
212
88
  return;
213
88
    }
214
215
    /* We need to delay the freeing of value->user */
216
3.65k
    if ((ctxt->value != NULL) && ctxt->value->boolval != 0) {
217
19
        user = ctxt->value->user;
218
19
  ctxt->value->boolval = 0;
219
19
  ctxt->value->user = NULL;
220
19
    }
221
3.65k
    ns = xmlXPathPopNodeSet(ctxt);
222
3.65k
    if (xmlXPathCheckError(ctxt))
223
46
  return;
224
225
3.60k
    ret = exsltMathHighest(ns);
226
227
3.60k
    xmlXPathFreeNodeSet(ns);
228
3.60k
    if (user != NULL)
229
0
        xmlFreeNodeList((xmlNodePtr)user);
230
231
3.60k
    xmlXPathReturnNodeSet(ctxt, ret);
232
3.60k
}
233
234
/**
235
 * exsltMathLowest:
236
 * @ns:  a node-set
237
 *
238
 * Implements the EXSLT - Math lowest() function
239
 *    node-set math:lowest (node-set)
240
 *
241
 * Returns the nodes in the node-set whose value is the minimum value
242
 *         for the node-set.
243
 */
244
static xmlNodeSetPtr
245
2.52k
exsltMathLowest (xmlNodeSetPtr ns) {
246
2.52k
    xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
247
2.52k
    double min, cur;
248
2.52k
    int i;
249
250
2.52k
    if ((ns == NULL) || (ns->nodeNr == 0))
251
237
  return(ret);
252
253
2.28k
    min = xmlXPathCastNodeToNumber(ns->nodeTab[0]);
254
2.28k
    if (xmlXPathIsNaN(min))
255
347
  return(ret);
256
1.94k
    else
257
1.94k
  xmlXPathNodeSetAddUnique(ret, ns->nodeTab[0]);
258
259
63.4k
    for (i = 1; i < ns->nodeNr; i++) {
260
62.8k
  cur = xmlXPathCastNodeToNumber(ns->nodeTab[i]);
261
62.8k
  if (xmlXPathIsNaN(cur)) {
262
1.26k
      xmlXPathEmptyNodeSet(ret);
263
1.26k
      return(ret);
264
1.26k
  }
265
61.5k
        if (cur > min)
266
32.4k
      continue;
267
29.1k
  if (cur < min) {
268
2.53k
      min = cur;
269
2.53k
      xmlXPathEmptyNodeSet(ret);
270
2.53k
      xmlXPathNodeSetAddUnique(ret, ns->nodeTab[i]);
271
2.53k
            continue;
272
2.53k
  }
273
26.5k
  xmlXPathNodeSetAddUnique(ret, ns->nodeTab[i]);
274
26.5k
    }
275
676
    return(ret);
276
1.94k
}
277
278
/**
279
 * exsltMathLowestFunction:
280
 * @ctxt:  an XPath parser context
281
 * @nargs:  the number of arguments
282
 *
283
 * Wraps #exsltMathLowest for use by the XPath processor
284
 */
285
static void
286
2.70k
exsltMathLowestFunction (xmlXPathParserContextPtr ctxt, int nargs) {
287
2.70k
    xmlNodeSetPtr ns, ret;
288
2.70k
    void *user = NULL;
289
290
291
2.70k
    if (nargs != 1) {
292
110
  xmlXPathSetArityError(ctxt);
293
110
  return;
294
110
    }
295
296
    /* We need to delay the freeing of value->user */
297
2.59k
    if ((ctxt->value != NULL) && (ctxt->value->boolval != 0)) {
298
30
        user = ctxt->value->user;
299
30
  ctxt->value->boolval = 0;
300
30
  ctxt->value->user = NULL;
301
30
    }
302
2.59k
    ns = xmlXPathPopNodeSet(ctxt);
303
2.59k
    if (xmlXPathCheckError(ctxt))
304
69
  return;
305
306
2.52k
    ret = exsltMathLowest(ns);
307
308
2.52k
    xmlXPathFreeNodeSet(ns);
309
2.52k
    if (user != NULL)
310
0
        xmlFreeNodeList((xmlNodePtr)user);
311
312
2.52k
    xmlXPathReturnNodeSet(ctxt, ret);
313
2.52k
}
314
315
/* math other functions */
316
317
/* constant values */
318
0
#define EXSLT_PI        (const xmlChar *) \
319
0
      "3.1415926535897932384626433832795028841971693993751"
320
1.07k
#define EXSLT_E         (const xmlChar *) \
321
1.07k
      "2.71828182845904523536028747135266249775724709369996"
322
0
#define EXSLT_SQRRT2    (const xmlChar *) \
323
0
      "1.41421356237309504880168872420969807856967187537694"
324
0
#define EXSLT_LN2       (const xmlChar *) \
325
0
      "0.69314718055994530941723212145817656807550013436025"
326
0
#define EXSLT_LN10      (const xmlChar *) \
327
0
      "2.30258509299404568402"
328
0
#define EXSLT_LOG2E     (const xmlChar *) \
329
0
      "1.4426950408889634074"
330
0
#define EXSLT_SQRT1_2   (const xmlChar *) \
331
0
      "0.70710678118654752440"
332
333
/**
334
 * exsltMathConstant
335
 * @name: string
336
 * @precision:  number
337
 *
338
 * Implements the EXSLT - Math constant function:
339
 *     number math:constant(string, number)
340
 *
341
 * Returns a number value of the given constant with the given precision or
342
 * xmlXPathNAN if name is unknown.
343
 * The constants are PI, E, SQRRT2, LN2, LN10, LOG2E, and SQRT1_2
344
 */
345
static double
346
1.09k
exsltMathConstant (xmlChar *name, double precision) {
347
1.09k
    xmlChar *str;
348
1.09k
    double ret;
349
350
1.09k
    if ((name == NULL) || (xmlXPathIsNaN(precision)) || (precision < 1.0)) {
351
246
        return xmlXPathNAN;
352
246
    }
353
354
853
    if (xmlStrEqual(name, BAD_CAST "PI")) {
355
0
        int len = xmlStrlen(EXSLT_PI);
356
357
0
        if (precision <= len)
358
0
            len = (int)precision;
359
360
0
        str = xmlStrsub(EXSLT_PI, 0, len);
361
362
853
    } else if (xmlStrEqual(name, BAD_CAST "E")) {
363
535
        int len = xmlStrlen(EXSLT_E);
364
365
535
        if (precision <= len)
366
478
            len = (int)precision;
367
368
535
        str = xmlStrsub(EXSLT_E, 0, len);
369
370
535
    } else if (xmlStrEqual(name, BAD_CAST "SQRRT2")) {
371
0
        int len = xmlStrlen(EXSLT_SQRRT2);
372
373
0
        if (precision <= len)
374
0
            len = (int)precision;
375
376
0
        str = xmlStrsub(EXSLT_SQRRT2, 0, len);
377
378
318
    } else if (xmlStrEqual(name, BAD_CAST "LN2")) {
379
0
        int len = xmlStrlen(EXSLT_LN2);
380
381
0
        if (precision <= len)
382
0
            len = (int)precision;
383
384
0
        str = xmlStrsub(EXSLT_LN2, 0, len);
385
386
318
    } else if (xmlStrEqual(name, BAD_CAST "LN10")) {
387
0
        int len = xmlStrlen(EXSLT_LN10);
388
389
0
        if (precision <= len)
390
0
            len = (int)precision;
391
392
0
        str = xmlStrsub(EXSLT_LN10, 0, len);
393
394
318
    } else if (xmlStrEqual(name, BAD_CAST "LOG2E")) {
395
0
        int len = xmlStrlen(EXSLT_LOG2E);
396
397
0
        if (precision <= len)
398
0
            len = (int)precision;
399
400
0
        str = xmlStrsub(EXSLT_LOG2E, 0, len);
401
402
318
    } else if (xmlStrEqual(name, BAD_CAST "SQRT1_2")) {
403
0
        int len = xmlStrlen(EXSLT_SQRT1_2);
404
405
0
        if (precision <= len)
406
0
            len = (int)precision;
407
408
0
        str = xmlStrsub(EXSLT_SQRT1_2, 0, len);
409
410
318
    } else {
411
318
  str = NULL;
412
318
    }
413
853
    if (str == NULL)
414
318
        return xmlXPathNAN;
415
535
    ret = xmlXPathCastStringToNumber(str);
416
535
    xmlFree(str);
417
535
    return ret;
418
853
}
419
420
/**
421
 * exsltMathConstantFunction:
422
 * @ctxt:  an XPath parser context
423
 * @nargs:  the number of arguments
424
 *
425
 * Wraps #exsltMathConstant for use by the XPath processor.
426
 */
427
static void
428
1.12k
exsltMathConstantFunction (xmlXPathParserContextPtr ctxt, int nargs) {
429
1.12k
    double   ret;
430
1.12k
    xmlChar *name;
431
432
1.12k
    if (nargs != 2) {
433
23
  xmlXPathSetArityError(ctxt);
434
23
  return;
435
23
    }
436
1.09k
    ret = xmlXPathPopNumber(ctxt);
437
1.09k
    if (xmlXPathCheckError(ctxt))
438
0
  return;
439
440
1.09k
    name = xmlXPathPopString(ctxt);
441
1.09k
    if (xmlXPathCheckError(ctxt))
442
0
  return;
443
444
1.09k
    ret = exsltMathConstant(name, ret);
445
1.09k
    if (name != NULL)
446
1.09k
  xmlFree(name);
447
448
1.09k
    xmlXPathReturnNumber(ctxt, ret);
449
1.09k
}
450
451
/**
452
 * exsltMathRandom:
453
 *
454
 * Implements the EXSLT - Math random() function:
455
 *    number math:random ()
456
 *
457
 * Returns a random number between 0 and 1 inclusive.
458
 */
459
static double
460
122
exsltMathRandom (void) {
461
122
    double ret;
462
122
    int num;
463
464
122
    num = rand();
465
122
    ret = (double)num / (double)RAND_MAX;
466
122
    return(ret);
467
122
}
468
469
/**
470
 * exsltMathRandomFunction:
471
 * @ctxt:  an XPath parser context
472
 * @nargs:  the number of arguments
473
 *
474
 * Wraps #exsltMathRandom for use by the XPath processor.
475
 */
476
static void
477
141
exsltMathRandomFunction (xmlXPathParserContextPtr ctxt, int nargs) {
478
141
    double ret;
479
480
141
    if (nargs != 0) {
481
19
  xmlXPathSetArityError(ctxt);
482
19
  return;
483
19
    }
484
485
122
    ret = exsltMathRandom();
486
487
122
    xmlXPathReturnNumber(ctxt, ret);
488
122
}
489
490
/**
491
 * exsltMathAbs:
492
 * @num:  a double
493
 *
494
 * Implements the EXSLT - Math abs() function:
495
 *    number math:abs (number)
496
 *
497
 * Returns the absolute value of the argument, or xmlXPathNAN if @num is Nan.
498
 */
499
static double
500
278
exsltMathAbs (double num) {
501
278
    double ret;
502
503
278
    if (xmlXPathIsNaN(num))
504
4
  return(xmlXPathNAN);
505
274
    ret = fabs(num);
506
274
    return(ret);
507
278
}
508
509
/**
510
 * exsltMathAbsFunction:
511
 * @ctxt:  an XPath parser context
512
 * @nargs:  the number of arguments
513
 *
514
 * Wraps #exsltMathAbs for use by the XPath processor.
515
 */
516
static void
517
299
exsltMathAbsFunction (xmlXPathParserContextPtr ctxt, int nargs) {
518
299
    double ret;
519
520
299
    if (nargs != 1) {
521
21
  xmlXPathSetArityError(ctxt);
522
21
  return;
523
21
    }
524
278
    ret = xmlXPathPopNumber(ctxt);
525
278
    if (xmlXPathCheckError(ctxt))
526
0
  return;
527
528
278
    ret = exsltMathAbs(ret);
529
530
278
    xmlXPathReturnNumber(ctxt, ret);
531
278
}
532
533
/**
534
 * exsltMathSqrt:
535
 * @num:  a double
536
 *
537
 * Implements the EXSLT - Math sqrt() function:
538
 *    number math:sqrt (number)
539
 *
540
 * Returns the square root of the argument, or xmlXPathNAN if @num is Nan.
541
 */
542
static double
543
524
exsltMathSqrt (double num) {
544
524
    double ret;
545
546
524
    if (xmlXPathIsNaN(num))
547
170
  return(xmlXPathNAN);
548
354
    ret = sqrt(num);
549
354
    return(ret);
550
524
}
551
552
/**
553
 * exsltMathSqrtFunction:
554
 * @ctxt:  an XPath parser context
555
 * @nargs:  the number of arguments
556
 *
557
 * Wraps #exsltMathSqrt for use by the XPath processor.
558
 */
559
static void
560
539
exsltMathSqrtFunction (xmlXPathParserContextPtr ctxt, int nargs) {
561
539
    double ret;
562
563
539
    if (nargs != 1) {
564
15
  xmlXPathSetArityError(ctxt);
565
15
  return;
566
15
    }
567
524
    ret = xmlXPathPopNumber(ctxt);
568
524
    if (xmlXPathCheckError(ctxt))
569
0
  return;
570
571
524
    ret = exsltMathSqrt(ret);
572
573
524
    xmlXPathReturnNumber(ctxt, ret);
574
524
}
575
576
/**
577
 * exsltMathPower:
578
 * @base:  a double
579
 * @power:  a double
580
 *
581
 * Implements the EXSLT - Math power() function:
582
 *    number math:power (number, number)
583
 *
584
 * Returns the power base and power arguments, or xmlXPathNAN
585
 * if either @base or @power is Nan.
586
 */
587
static double
588
590
exsltMathPower (double base, double power) {
589
590
    double ret;
590
591
590
    if ((xmlXPathIsNaN(base) || xmlXPathIsNaN(power)))
592
262
  return(xmlXPathNAN);
593
328
    ret = pow(base, power);
594
328
    return(ret);
595
590
}
596
597
/**
598
 * exsltMathPower:
599
 * @ctxt:  an XPath parser context
600
 * @nargs:  the number of arguments
601
 *
602
 * Wraps #exsltMathPower for use by the XPath processor.
603
 */
604
static void
605
636
exsltMathPowerFunction (xmlXPathParserContextPtr ctxt, int nargs) {
606
636
    double ret, base;
607
608
636
    if (nargs != 2) {
609
46
  xmlXPathSetArityError(ctxt);
610
46
  return;
611
46
    }
612
590
    ret = xmlXPathPopNumber(ctxt);
613
590
    if (xmlXPathCheckError(ctxt))
614
0
  return;
615
616
    /* power */
617
590
    base = xmlXPathPopNumber(ctxt);
618
590
    if (xmlXPathCheckError(ctxt))
619
0
  return;
620
621
590
    ret = exsltMathPower(base, ret);
622
623
590
    xmlXPathReturnNumber(ctxt, ret);
624
590
}
625
626
/**
627
 * exsltMathLog:
628
 * @num:  a double
629
 *
630
 * Implements the EXSLT - Math log() function:
631
 *    number math:log (number)
632
 *
633
 * Returns the natural log of the argument, or xmlXPathNAN if @num is Nan.
634
 */
635
static double
636
1.06k
exsltMathLog (double num) {
637
1.06k
    double ret;
638
639
1.06k
    if (xmlXPathIsNaN(num))
640
248
  return(xmlXPathNAN);
641
815
    ret = log(num);
642
815
    return(ret);
643
1.06k
}
644
645
/**
646
 * exsltMathLogFunction:
647
 * @ctxt:  an XPath parser context
648
 * @nargs:  the number of arguments
649
 *
650
 * Wraps #exsltMathLog for use by the XPath processor.
651
 */
652
static void
653
1.08k
exsltMathLogFunction (xmlXPathParserContextPtr ctxt, int nargs) {
654
1.08k
    double ret;
655
656
1.08k
    if (nargs != 1) {
657
19
  xmlXPathSetArityError(ctxt);
658
19
  return;
659
19
    }
660
1.06k
    ret = xmlXPathPopNumber(ctxt);
661
1.06k
    if (xmlXPathCheckError(ctxt))
662
0
  return;
663
664
1.06k
    ret = exsltMathLog(ret);
665
666
1.06k
    xmlXPathReturnNumber(ctxt, ret);
667
1.06k
}
668
669
/**
670
 * exsltMathSin:
671
 * @num:  a double
672
 *
673
 * Implements the EXSLT - Math sin() function:
674
 *    number math:sin (number)
675
 *
676
 * Returns the sine of the argument, or xmlXPathNAN if @num is Nan.
677
 */
678
static double
679
847
exsltMathSin (double num) {
680
847
    double ret;
681
682
847
    if (xmlXPathIsNaN(num))
683
442
  return(xmlXPathNAN);
684
405
    ret = sin(num);
685
405
    return(ret);
686
847
}
687
688
/**
689
 * exsltMathSinFunction:
690
 * @ctxt:  an XPath parser context
691
 * @nargs:  the number of arguments
692
 *
693
 * Wraps #exsltMathSin for use by the XPath processor.
694
 */
695
static void
696
881
exsltMathSinFunction (xmlXPathParserContextPtr ctxt, int nargs) {
697
881
    double ret;
698
699
881
    if (nargs != 1) {
700
34
  xmlXPathSetArityError(ctxt);
701
34
  return;
702
34
    }
703
847
    ret = xmlXPathPopNumber(ctxt);
704
847
    if (xmlXPathCheckError(ctxt))
705
0
  return;
706
707
847
    ret = exsltMathSin(ret);
708
709
847
    xmlXPathReturnNumber(ctxt, ret);
710
847
}
711
712
/**
713
 * exsltMathCos:
714
 * @num:  a double
715
 *
716
 * Implements the EXSLT - Math cos() function:
717
 *    number math:cos (number)
718
 *
719
 * Returns the cosine of the argument, or xmlXPathNAN if @num is Nan.
720
 */
721
static double
722
1.06k
exsltMathCos (double num) {
723
1.06k
    double ret;
724
725
1.06k
    if (xmlXPathIsNaN(num))
726
587
  return(xmlXPathNAN);
727
478
    ret = cos(num);
728
478
    return(ret);
729
1.06k
}
730
731
/**
732
 * exsltMathCosFunction:
733
 * @ctxt:  an XPath parser context
734
 * @nargs:  the number of arguments
735
 *
736
 * Wraps #exsltMathCos for use by the XPath processor.
737
 */
738
static void
739
1.08k
exsltMathCosFunction (xmlXPathParserContextPtr ctxt, int nargs) {
740
1.08k
    double ret;
741
742
1.08k
    if (nargs != 1) {
743
23
  xmlXPathSetArityError(ctxt);
744
23
  return;
745
23
    }
746
1.06k
    ret = xmlXPathPopNumber(ctxt);
747
1.06k
    if (xmlXPathCheckError(ctxt))
748
0
  return;
749
750
1.06k
    ret = exsltMathCos(ret);
751
752
1.06k
    xmlXPathReturnNumber(ctxt, ret);
753
1.06k
}
754
755
/**
756
 * exsltMathTan:
757
 * @num:  a double
758
 *
759
 * Implements the EXSLT - Math tan() function:
760
 *    number math:tan (number)
761
 *
762
 * Returns the tangent of the argument, or xmlXPathNAN if @num is Nan.
763
 */
764
static double
765
983
exsltMathTan (double num) {
766
983
    double ret;
767
768
983
    if (xmlXPathIsNaN(num))
769
469
  return(xmlXPathNAN);
770
514
    ret = tan(num);
771
514
    return(ret);
772
983
}
773
774
/**
775
 * exsltMathTanFunction:
776
 * @ctxt:  an XPath parser context
777
 * @nargs:  the number of arguments
778
 *
779
 * Wraps #exsltMathTan for use by the XPath processor.
780
 */
781
static void
782
1.00k
exsltMathTanFunction (xmlXPathParserContextPtr ctxt, int nargs) {
783
1.00k
    double ret;
784
785
1.00k
    if (nargs != 1) {
786
24
  xmlXPathSetArityError(ctxt);
787
24
  return;
788
24
    }
789
983
    ret = xmlXPathPopNumber(ctxt);
790
983
    if (xmlXPathCheckError(ctxt))
791
0
  return;
792
793
983
    ret = exsltMathTan(ret);
794
795
983
    xmlXPathReturnNumber(ctxt, ret);
796
983
}
797
798
/**
799
 * exsltMathAsin:
800
 * @num:  a double
801
 *
802
 * Implements the EXSLT - Math asin() function:
803
 *    number math:asin (number)
804
 *
805
 * Returns the arc sine of the argument, or xmlXPathNAN if @num is Nan.
806
 */
807
static double
808
1.17k
exsltMathAsin (double num) {
809
1.17k
    double ret;
810
811
1.17k
    if (xmlXPathIsNaN(num))
812
538
  return(xmlXPathNAN);
813
635
    ret = asin(num);
814
635
    return(ret);
815
1.17k
}
816
817
/**
818
 * exsltMathAsinFunction:
819
 * @ctxt:  an XPath parser context
820
 * @nargs:  the number of arguments
821
 *
822
 * Wraps #exsltMathAsin for use by the XPath processor.
823
 */
824
static void
825
1.19k
exsltMathAsinFunction (xmlXPathParserContextPtr ctxt, int nargs) {
826
1.19k
    double ret;
827
828
1.19k
    if (nargs != 1) {
829
25
  xmlXPathSetArityError(ctxt);
830
25
  return;
831
25
    }
832
1.17k
    ret = xmlXPathPopNumber(ctxt);
833
1.17k
    if (xmlXPathCheckError(ctxt))
834
0
  return;
835
836
1.17k
    ret = exsltMathAsin(ret);
837
838
1.17k
    xmlXPathReturnNumber(ctxt, ret);
839
1.17k
}
840
841
/**
842
 * exsltMathAcos:
843
 * @num:  a double
844
 *
845
 * Implements the EXSLT - Math acos() function:
846
 *    number math:acos (number)
847
 *
848
 * Returns the arc cosine of the argument, or xmlXPathNAN if @num is Nan.
849
 */
850
static double
851
842
exsltMathAcos (double num) {
852
842
    double ret;
853
854
842
    if (xmlXPathIsNaN(num))
855
510
  return(xmlXPathNAN);
856
332
    ret = acos(num);
857
332
    return(ret);
858
842
}
859
860
/**
861
 * exsltMathAcosFunction:
862
 * @ctxt:  an XPath parser context
863
 * @nargs:  the number of arguments
864
 *
865
 * Wraps #exsltMathAcos for use by the XPath processor.
866
 */
867
static void
868
859
exsltMathAcosFunction (xmlXPathParserContextPtr ctxt, int nargs) {
869
859
    double ret;
870
871
859
    if (nargs != 1) {
872
17
  xmlXPathSetArityError(ctxt);
873
17
  return;
874
17
    }
875
842
    ret = xmlXPathPopNumber(ctxt);
876
842
    if (xmlXPathCheckError(ctxt))
877
0
  return;
878
879
842
    ret = exsltMathAcos(ret);
880
881
842
    xmlXPathReturnNumber(ctxt, ret);
882
842
}
883
884
/**
885
 * exsltMathAtan:
886
 * @num:  a double
887
 *
888
 * Implements the EXSLT - Math atan() function:
889
 *    number math:atan (number)
890
 *
891
 * Returns the arc tangent of the argument, or xmlXPathNAN if @num is Nan.
892
 */
893
static double
894
519
exsltMathAtan (double num) {
895
519
    double ret;
896
897
519
    if (xmlXPathIsNaN(num))
898
280
  return(xmlXPathNAN);
899
239
    ret = atan(num);
900
239
    return(ret);
901
519
}
902
903
/**
904
 * exsltMathAtanFunction:
905
 * @ctxt:  an XPath parser context
906
 * @nargs:  the number of arguments
907
 *
908
 * Wraps #exsltMathAtan for use by the XPath processor.
909
 */
910
static void
911
550
exsltMathAtanFunction (xmlXPathParserContextPtr ctxt, int nargs) {
912
550
    double ret;
913
914
550
    if (nargs != 1) {
915
31
  xmlXPathSetArityError(ctxt);
916
31
  return;
917
31
    }
918
519
    ret = xmlXPathPopNumber(ctxt);
919
519
    if (xmlXPathCheckError(ctxt))
920
0
  return;
921
922
519
    ret = exsltMathAtan(ret);
923
924
519
    xmlXPathReturnNumber(ctxt, ret);
925
519
}
926
927
/**
928
 * exsltMathAtan2:
929
 * @y:  a double
930
 * @x:  a double
931
 *
932
 * Implements the EXSLT - Math atan2() function:
933
 *    number math:atan2 (number, number)
934
 *
935
 * Returns the arc tangent function of the y/x arguments, or xmlXPathNAN
936
 * if either @y or @x is Nan.
937
 */
938
static double
939
1.05k
exsltMathAtan2 (double y, double x) {
940
1.05k
    double ret;
941
942
1.05k
    if ((xmlXPathIsNaN(y) || xmlXPathIsNaN(x)))
943
576
  return(xmlXPathNAN);
944
475
    ret = atan2(y, x);
945
475
    return(ret);
946
1.05k
}
947
948
/**
949
 * exsltMathAtan2Function:
950
 * @ctxt:  an XPath parser context
951
 * @nargs:  the number of arguments
952
 *
953
 * Wraps #exsltMathAtan2 for use by the XPath processor.
954
 */
955
static void
956
1.12k
exsltMathAtan2Function (xmlXPathParserContextPtr ctxt, int nargs) {
957
1.12k
    double ret, x;
958
959
1.12k
    if (nargs != 2) {
960
78
  xmlXPathSetArityError(ctxt);
961
78
  return;
962
78
    }
963
1.05k
    x = xmlXPathPopNumber(ctxt);
964
1.05k
    if (xmlXPathCheckError(ctxt))
965
0
  return;
966
967
    /* y */
968
1.05k
    ret = xmlXPathPopNumber(ctxt);
969
1.05k
    if (xmlXPathCheckError(ctxt))
970
0
  return;
971
972
1.05k
    ret = exsltMathAtan2(ret, x);
973
974
1.05k
    xmlXPathReturnNumber(ctxt, ret);
975
1.05k
}
976
977
/**
978
 * exsltMathExp:
979
 * @num:  a double
980
 *
981
 * Implements the EXSLT - Math exp() function:
982
 *    number math:exp (number)
983
 *
984
 * Returns the exponential function of the argument, or xmlXPathNAN if
985
 * @num is Nan.
986
 */
987
static double
988
709
exsltMathExp (double num) {
989
709
    double ret;
990
991
709
    if (xmlXPathIsNaN(num))
992
292
  return(xmlXPathNAN);
993
417
    ret = exp(num);
994
417
    return(ret);
995
709
}
996
997
/**
998
 * exsltMathExpFunction:
999
 * @ctxt:  an XPath parser context
1000
 * @nargs:  the number of arguments
1001
 *
1002
 * Wraps #exsltMathExp for use by the XPath processor.
1003
 */
1004
static void
1005
726
exsltMathExpFunction (xmlXPathParserContextPtr ctxt, int nargs) {
1006
726
    double ret;
1007
1008
726
    if (nargs != 1) {
1009
17
  xmlXPathSetArityError(ctxt);
1010
17
  return;
1011
17
    }
1012
709
    ret = xmlXPathPopNumber(ctxt);
1013
709
    if (xmlXPathCheckError(ctxt))
1014
0
  return;
1015
1016
709
    ret = exsltMathExp(ret);
1017
1018
709
    xmlXPathReturnNumber(ctxt, ret);
1019
709
}
1020
1021
/**
1022
 * exsltMathRegister:
1023
 *
1024
 * Registers the EXSLT - Math module
1025
 */
1026
1027
void
1028
3.69k
exsltMathRegister (void) {
1029
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "min",
1030
3.69k
           EXSLT_MATH_NAMESPACE,
1031
3.69k
           exsltMathMinFunction);
1032
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "max",
1033
3.69k
           EXSLT_MATH_NAMESPACE,
1034
3.69k
           exsltMathMaxFunction);
1035
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "highest",
1036
3.69k
           EXSLT_MATH_NAMESPACE,
1037
3.69k
           exsltMathHighestFunction);
1038
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "lowest",
1039
3.69k
           EXSLT_MATH_NAMESPACE,
1040
3.69k
           exsltMathLowestFunction);
1041
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "constant",
1042
3.69k
           EXSLT_MATH_NAMESPACE,
1043
3.69k
           exsltMathConstantFunction);
1044
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "random",
1045
3.69k
           EXSLT_MATH_NAMESPACE,
1046
3.69k
           exsltMathRandomFunction);
1047
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "abs",
1048
3.69k
           EXSLT_MATH_NAMESPACE,
1049
3.69k
           exsltMathAbsFunction);
1050
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "sqrt",
1051
3.69k
           EXSLT_MATH_NAMESPACE,
1052
3.69k
           exsltMathSqrtFunction);
1053
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "power",
1054
3.69k
           EXSLT_MATH_NAMESPACE,
1055
3.69k
           exsltMathPowerFunction);
1056
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "log",
1057
3.69k
           EXSLT_MATH_NAMESPACE,
1058
3.69k
           exsltMathLogFunction);
1059
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "sin",
1060
3.69k
           EXSLT_MATH_NAMESPACE,
1061
3.69k
           exsltMathSinFunction);
1062
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "cos",
1063
3.69k
           EXSLT_MATH_NAMESPACE,
1064
3.69k
           exsltMathCosFunction);
1065
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "tan",
1066
3.69k
           EXSLT_MATH_NAMESPACE,
1067
3.69k
           exsltMathTanFunction);
1068
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "asin",
1069
3.69k
           EXSLT_MATH_NAMESPACE,
1070
3.69k
           exsltMathAsinFunction);
1071
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "acos",
1072
3.69k
           EXSLT_MATH_NAMESPACE,
1073
3.69k
           exsltMathAcosFunction);
1074
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "atan",
1075
3.69k
           EXSLT_MATH_NAMESPACE,
1076
3.69k
           exsltMathAtanFunction);
1077
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "atan2",
1078
3.69k
           EXSLT_MATH_NAMESPACE,
1079
3.69k
           exsltMathAtan2Function);
1080
3.69k
    xsltRegisterExtModuleFunction ((const xmlChar *) "exp",
1081
3.69k
           EXSLT_MATH_NAMESPACE,
1082
3.69k
           exsltMathExpFunction);
1083
3.69k
}
1084
1085
/**
1086
 * exsltMathXpathCtxtRegister:
1087
 *
1088
 * Registers the EXSLT - Math module for use outside XSLT
1089
 */
1090
int
1091
exsltMathXpathCtxtRegister (xmlXPathContextPtr ctxt, const xmlChar *prefix)
1092
0
{
1093
0
    if (ctxt
1094
0
        && prefix
1095
0
        && !xmlXPathRegisterNs(ctxt,
1096
0
                               prefix,
1097
0
                               (const xmlChar *) EXSLT_MATH_NAMESPACE)
1098
0
        && !xmlXPathRegisterFuncNS(ctxt,
1099
0
                                   (const xmlChar *) "min",
1100
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1101
0
                                   exsltMathMinFunction)
1102
0
        && !xmlXPathRegisterFuncNS(ctxt,
1103
0
                                   (const xmlChar *) "max",
1104
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1105
0
                                   exsltMathMaxFunction)
1106
0
        && !xmlXPathRegisterFuncNS(ctxt,
1107
0
                                   (const xmlChar *) "highest",
1108
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1109
0
                                   exsltMathHighestFunction)
1110
0
        && !xmlXPathRegisterFuncNS(ctxt,
1111
0
                                   (const xmlChar *) "lowest",
1112
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1113
0
                                   exsltMathLowestFunction)
1114
0
        && !xmlXPathRegisterFuncNS(ctxt,
1115
0
                                   (const xmlChar *) "random",
1116
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1117
0
                                   exsltMathRandomFunction)
1118
0
        && !xmlXPathRegisterFuncNS(ctxt,
1119
0
                                   (const xmlChar *) "abs",
1120
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1121
0
                                   exsltMathAbsFunction)
1122
0
        && !xmlXPathRegisterFuncNS(ctxt,
1123
0
                                   (const xmlChar *) "sqrt",
1124
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1125
0
                                   exsltMathSqrtFunction)
1126
0
        && !xmlXPathRegisterFuncNS(ctxt,
1127
0
                                   (const xmlChar *) "power",
1128
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1129
0
                                   exsltMathPowerFunction)
1130
0
        && !xmlXPathRegisterFuncNS(ctxt,
1131
0
                                   (const xmlChar *) "log",
1132
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1133
0
                                   exsltMathLogFunction)
1134
0
        && !xmlXPathRegisterFuncNS(ctxt,
1135
0
                                   (const xmlChar *) "sin",
1136
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1137
0
                                   exsltMathSinFunction)
1138
0
        && !xmlXPathRegisterFuncNS(ctxt,
1139
0
                                   (const xmlChar *) "cos",
1140
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1141
0
                                   exsltMathCosFunction)
1142
0
        && !xmlXPathRegisterFuncNS(ctxt,
1143
0
                                   (const xmlChar *) "tan",
1144
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1145
0
                                   exsltMathTanFunction)
1146
0
        && !xmlXPathRegisterFuncNS(ctxt,
1147
0
                                   (const xmlChar *) "asin",
1148
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1149
0
                                   exsltMathAsinFunction)
1150
0
        && !xmlXPathRegisterFuncNS(ctxt,
1151
0
                                   (const xmlChar *) "acos",
1152
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1153
0
                                   exsltMathAcosFunction)
1154
0
        && !xmlXPathRegisterFuncNS(ctxt,
1155
0
                                   (const xmlChar *) "atan",
1156
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1157
0
                                   exsltMathAtanFunction)
1158
0
        && !xmlXPathRegisterFuncNS(ctxt,
1159
0
                                   (const xmlChar *) "atan2",
1160
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1161
0
                                   exsltMathAtan2Function)
1162
0
        && !xmlXPathRegisterFuncNS(ctxt,
1163
0
                                   (const xmlChar *) "exp",
1164
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1165
0
                                   exsltMathExpFunction)
1166
0
        && !xmlXPathRegisterFuncNS(ctxt,
1167
0
                                   (const xmlChar *) "constant",
1168
0
                                   (const xmlChar *) EXSLT_MATH_NAMESPACE,
1169
0
                                   exsltMathConstantFunction)) {
1170
0
        return 0;
1171
0
    }
1172
0
    return -1;
1173
0
}