Coverage Report

Created: 2024-01-20 12:31

/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
353
exsltMathMin (xmlNodeSetPtr ns) {
30
353
    double ret, cur;
31
353
    int i;
32
33
353
    if ((ns == NULL) || (ns->nodeNr == 0))
34
37
  return(xmlXPathNAN);
35
316
    ret = xmlXPathCastNodeToNumber(ns->nodeTab[0]);
36
316
    if (xmlXPathIsNaN(ret))
37
61
  return(xmlXPathNAN);
38
2.69k
    for (i = 1; i < ns->nodeNr; i++) {
39
2.63k
  cur = xmlXPathCastNodeToNumber(ns->nodeTab[i]);
40
2.63k
  if (xmlXPathIsNaN(cur))
41
195
      return(xmlXPathNAN);
42
2.43k
  if (cur < ret)
43
347
      ret = cur;
44
2.43k
    }
45
60
    return(ret);
46
255
}
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
449
exsltMathMinFunction (xmlXPathParserContextPtr ctxt, int nargs) {
57
449
    xmlNodeSetPtr ns;
58
449
    double ret;
59
449
    void *user = NULL;
60
61
449
    if (nargs != 1) {
62
21
  xsltGenericError(xsltGenericErrorContext,
63
21
       "math:min: invalid number of arguments\n");
64
21
  ctxt->error = XPATH_INVALID_ARITY;
65
21
  return;
66
21
    }
67
    /* We need to delay the freeing of value->user */
68
428
    if ((ctxt->value != NULL) && (ctxt->value->boolval != 0)) {
69
14
        user = ctxt->value->user;
70
14
  ctxt->value->boolval = 0;
71
14
  ctxt->value->user = NULL;
72
14
    }
73
428
    ns = xmlXPathPopNodeSet(ctxt);
74
428
    if (xmlXPathCheckError(ctxt))
75
75
  return;
76
77
353
    ret = exsltMathMin(ns);
78
79
353
    xmlXPathFreeNodeSet(ns);
80
353
    if (user != NULL)
81
0
        xmlFreeNodeList((xmlNodePtr)user);
82
83
353
    xmlXPathReturnNumber(ctxt, ret);
84
353
}
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
441
exsltMathMax (xmlNodeSetPtr ns) {
99
441
    double ret, cur;
100
441
    int i;
101
102
441
    if ((ns == NULL) || (ns->nodeNr == 0))
103
47
  return(xmlXPathNAN);
104
394
    ret = xmlXPathCastNodeToNumber(ns->nodeTab[0]);
105
394
    if (xmlXPathIsNaN(ret))
106
84
  return(xmlXPathNAN);
107
4.30k
    for (i = 1; i < ns->nodeNr; i++) {
108
4.24k
  cur = xmlXPathCastNodeToNumber(ns->nodeTab[i]);
109
4.24k
  if (xmlXPathIsNaN(cur))
110
247
      return(xmlXPathNAN);
111
3.99k
  if (cur > ret)
112
90
      ret = cur;
113
3.99k
    }
114
63
    return(ret);
115
310
}
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
537
exsltMathMaxFunction (xmlXPathParserContextPtr ctxt, int nargs) {
126
537
    xmlNodeSetPtr ns;
127
537
    double ret;
128
537
    void *user = NULL;
129
130
537
    if (nargs != 1) {
131
33
  xmlXPathSetArityError(ctxt);
132
33
  return;
133
33
    }
134
135
    /* We need to delay the freeing of value->user */
136
504
    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
504
    ns = xmlXPathPopNodeSet(ctxt);
142
504
    if (xmlXPathCheckError(ctxt))
143
63
  return;
144
145
441
    ret = exsltMathMax(ns);
146
147
441
    xmlXPathFreeNodeSet(ns);
148
149
441
    if (user != NULL)
150
0
        xmlFreeNodeList((xmlNodePtr)user);
151
441
    xmlXPathReturnNumber(ctxt, ret);
152
441
}
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
867
exsltMathHighest (xmlNodeSetPtr ns) {
166
867
    xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
167
867
    double max, cur;
168
867
    int i;
169
170
867
    if ((ns == NULL) || (ns->nodeNr == 0))
171
53
  return(ret);
172
173
814
    max = xmlXPathCastNodeToNumber(ns->nodeTab[0]);
174
814
    if (xmlXPathIsNaN(max))
175
75
  return(ret);
176
739
    else
177
739
  xmlXPathNodeSetAddUnique(ret, ns->nodeTab[0]);
178
179
34.2k
    for (i = 1; i < ns->nodeNr; i++) {
180
34.1k
  cur = xmlXPathCastNodeToNumber(ns->nodeTab[i]);
181
34.1k
  if (xmlXPathIsNaN(cur)) {
182
643
      xmlXPathEmptyNodeSet(ret);
183
643
      return(ret);
184
643
  }
185
33.5k
  if (cur < max)
186
17.1k
      continue;
187
16.3k
  if (cur > max) {
188
742
      max = cur;
189
742
      xmlXPathEmptyNodeSet(ret);
190
742
      xmlXPathNodeSetAddUnique(ret, ns->nodeTab[i]);
191
742
      continue;
192
742
  }
193
15.6k
  xmlXPathNodeSetAddUnique(ret, ns->nodeTab[i]);
194
15.6k
    }
195
96
    return(ret);
196
739
}
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
959
exsltMathHighestFunction (xmlXPathParserContextPtr ctxt, int nargs) {
207
959
    xmlNodeSetPtr ns, ret;
208
959
    void *user = NULL;
209
210
959
    if (nargs != 1) {
211
42
  xmlXPathSetArityError(ctxt);
212
42
  return;
213
42
    }
214
215
    /* We need to delay the freeing of value->user */
216
917
    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
917
    ns = xmlXPathPopNodeSet(ctxt);
222
917
    if (xmlXPathCheckError(ctxt))
223
50
  return;
224
225
867
    ret = exsltMathHighest(ns);
226
227
867
    xmlXPathFreeNodeSet(ns);
228
867
    if (user != NULL)
229
0
        xmlFreeNodeList((xmlNodePtr)user);
230
231
867
    xmlXPathReturnNodeSet(ctxt, ret);
232
867
}
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
787
exsltMathLowest (xmlNodeSetPtr ns) {
246
787
    xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
247
787
    double min, cur;
248
787
    int i;
249
250
787
    if ((ns == NULL) || (ns->nodeNr == 0))
251
36
  return(ret);
252
253
751
    min = xmlXPathCastNodeToNumber(ns->nodeTab[0]);
254
751
    if (xmlXPathIsNaN(min))
255
77
  return(ret);
256
674
    else
257
674
  xmlXPathNodeSetAddUnique(ret, ns->nodeTab[0]);
258
259
53.2k
    for (i = 1; i < ns->nodeNr; i++) {
260
53.1k
  cur = xmlXPathCastNodeToNumber(ns->nodeTab[i]);
261
53.1k
  if (xmlXPathIsNaN(cur)) {
262
576
      xmlXPathEmptyNodeSet(ret);
263
576
      return(ret);
264
576
  }
265
52.5k
        if (cur > min)
266
34.2k
      continue;
267
18.3k
  if (cur < min) {
268
1.06k
      min = cur;
269
1.06k
      xmlXPathEmptyNodeSet(ret);
270
1.06k
      xmlXPathNodeSetAddUnique(ret, ns->nodeTab[i]);
271
1.06k
            continue;
272
1.06k
  }
273
17.2k
  xmlXPathNodeSetAddUnique(ret, ns->nodeTab[i]);
274
17.2k
    }
275
98
    return(ret);
276
674
}
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
843
exsltMathLowestFunction (xmlXPathParserContextPtr ctxt, int nargs) {
287
843
    xmlNodeSetPtr ns, ret;
288
843
    void *user = NULL;
289
290
291
843
    if (nargs != 1) {
292
21
  xmlXPathSetArityError(ctxt);
293
21
  return;
294
21
    }
295
296
    /* We need to delay the freeing of value->user */
297
822
    if ((ctxt->value != NULL) && (ctxt->value->boolval != 0)) {
298
15
        user = ctxt->value->user;
299
15
  ctxt->value->boolval = 0;
300
15
  ctxt->value->user = NULL;
301
15
    }
302
822
    ns = xmlXPathPopNodeSet(ctxt);
303
822
    if (xmlXPathCheckError(ctxt))
304
35
  return;
305
306
787
    ret = exsltMathLowest(ns);
307
308
787
    xmlXPathFreeNodeSet(ns);
309
787
    if (user != NULL)
310
0
        xmlFreeNodeList((xmlNodePtr)user);
311
312
787
    xmlXPathReturnNodeSet(ctxt, ret);
313
787
}
314
315
/* math other functions */
316
317
/* constant values */
318
0
#define EXSLT_PI        (const xmlChar *) \
319
0
      "3.1415926535897932384626433832795028841971693993751"
320
40
#define EXSLT_E         (const xmlChar *) \
321
40
      "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
52
exsltMathConstant (xmlChar *name, double precision) {
347
52
    xmlChar *str;
348
52
    double ret;
349
350
52
    if ((name == NULL) || (xmlXPathIsNaN(precision)) || (precision < 1.0)) {
351
14
        return xmlXPathNAN;
352
14
    }
353
354
38
    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
38
    } else if (xmlStrEqual(name, BAD_CAST "E")) {
363
20
        int len = xmlStrlen(EXSLT_E);
364
365
20
        if (precision <= len)
366
20
            len = (int)precision;
367
368
20
        str = xmlStrsub(EXSLT_E, 0, len);
369
370
20
    } 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
18
    } 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
18
    } 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
18
    } 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
18
    } 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
18
    } else {
411
18
  str = NULL;
412
18
    }
413
38
    if (str == NULL)
414
18
        return xmlXPathNAN;
415
20
    ret = xmlXPathCastStringToNumber(str);
416
20
    xmlFree(str);
417
20
    return ret;
418
38
}
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
67
exsltMathConstantFunction (xmlXPathParserContextPtr ctxt, int nargs) {
429
67
    double   ret;
430
67
    xmlChar *name;
431
432
67
    if (nargs != 2) {
433
15
  xmlXPathSetArityError(ctxt);
434
15
  return;
435
15
    }
436
52
    ret = xmlXPathPopNumber(ctxt);
437
52
    if (xmlXPathCheckError(ctxt))
438
0
  return;
439
440
52
    name = xmlXPathPopString(ctxt);
441
52
    if (xmlXPathCheckError(ctxt))
442
0
  return;
443
444
52
    ret = exsltMathConstant(name, ret);
445
52
    if (name != NULL)
446
52
  xmlFree(name);
447
448
52
    xmlXPathReturnNumber(ctxt, ret);
449
52
}
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
19
exsltMathRandom (void) {
461
19
    double ret;
462
19
    int num;
463
464
19
    num = rand();
465
19
    ret = (double)num / (double)RAND_MAX;
466
19
    return(ret);
467
19
}
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
35
exsltMathRandomFunction (xmlXPathParserContextPtr ctxt, int nargs) {
478
35
    double ret;
479
480
35
    if (nargs != 0) {
481
16
  xmlXPathSetArityError(ctxt);
482
16
  return;
483
16
    }
484
485
19
    ret = exsltMathRandom();
486
487
19
    xmlXPathReturnNumber(ctxt, ret);
488
19
}
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
34
exsltMathAbs (double num) {
501
34
    double ret;
502
503
34
    if (xmlXPathIsNaN(num))
504
7
  return(xmlXPathNAN);
505
27
    ret = fabs(num);
506
27
    return(ret);
507
34
}
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
49
exsltMathAbsFunction (xmlXPathParserContextPtr ctxt, int nargs) {
518
49
    double ret;
519
520
49
    if (nargs != 1) {
521
15
  xmlXPathSetArityError(ctxt);
522
15
  return;
523
15
    }
524
34
    ret = xmlXPathPopNumber(ctxt);
525
34
    if (xmlXPathCheckError(ctxt))
526
0
  return;
527
528
34
    ret = exsltMathAbs(ret);
529
530
34
    xmlXPathReturnNumber(ctxt, ret);
531
34
}
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
31
exsltMathSqrt (double num) {
544
31
    double ret;
545
546
31
    if (xmlXPathIsNaN(num))
547
15
  return(xmlXPathNAN);
548
16
    ret = sqrt(num);
549
16
    return(ret);
550
31
}
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
47
exsltMathSqrtFunction (xmlXPathParserContextPtr ctxt, int nargs) {
561
47
    double ret;
562
563
47
    if (nargs != 1) {
564
16
  xmlXPathSetArityError(ctxt);
565
16
  return;
566
16
    }
567
31
    ret = xmlXPathPopNumber(ctxt);
568
31
    if (xmlXPathCheckError(ctxt))
569
0
  return;
570
571
31
    ret = exsltMathSqrt(ret);
572
573
31
    xmlXPathReturnNumber(ctxt, ret);
574
31
}
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
61
exsltMathPower (double base, double power) {
589
61
    double ret;
590
591
61
    if ((xmlXPathIsNaN(base) || xmlXPathIsNaN(power)))
592
44
  return(xmlXPathNAN);
593
17
    ret = pow(base, power);
594
17
    return(ret);
595
61
}
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
77
exsltMathPowerFunction (xmlXPathParserContextPtr ctxt, int nargs) {
606
77
    double ret, base;
607
608
77
    if (nargs != 2) {
609
16
  xmlXPathSetArityError(ctxt);
610
16
  return;
611
16
    }
612
61
    ret = xmlXPathPopNumber(ctxt);
613
61
    if (xmlXPathCheckError(ctxt))
614
0
  return;
615
616
    /* power */
617
61
    base = xmlXPathPopNumber(ctxt);
618
61
    if (xmlXPathCheckError(ctxt))
619
0
  return;
620
621
61
    ret = exsltMathPower(base, ret);
622
623
61
    xmlXPathReturnNumber(ctxt, ret);
624
61
}
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
46
exsltMathLog (double num) {
637
46
    double ret;
638
639
46
    if (xmlXPathIsNaN(num))
640
24
  return(xmlXPathNAN);
641
22
    ret = log(num);
642
22
    return(ret);
643
46
}
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
62
exsltMathLogFunction (xmlXPathParserContextPtr ctxt, int nargs) {
654
62
    double ret;
655
656
62
    if (nargs != 1) {
657
16
  xmlXPathSetArityError(ctxt);
658
16
  return;
659
16
    }
660
46
    ret = xmlXPathPopNumber(ctxt);
661
46
    if (xmlXPathCheckError(ctxt))
662
0
  return;
663
664
46
    ret = exsltMathLog(ret);
665
666
46
    xmlXPathReturnNumber(ctxt, ret);
667
46
}
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
109
exsltMathSin (double num) {
680
109
    double ret;
681
682
109
    if (xmlXPathIsNaN(num))
683
67
  return(xmlXPathNAN);
684
42
    ret = sin(num);
685
42
    return(ret);
686
109
}
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
124
exsltMathSinFunction (xmlXPathParserContextPtr ctxt, int nargs) {
697
124
    double ret;
698
699
124
    if (nargs != 1) {
700
15
  xmlXPathSetArityError(ctxt);
701
15
  return;
702
15
    }
703
109
    ret = xmlXPathPopNumber(ctxt);
704
109
    if (xmlXPathCheckError(ctxt))
705
0
  return;
706
707
109
    ret = exsltMathSin(ret);
708
709
109
    xmlXPathReturnNumber(ctxt, ret);
710
109
}
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
181
exsltMathCos (double num) {
723
181
    double ret;
724
725
181
    if (xmlXPathIsNaN(num))
726
115
  return(xmlXPathNAN);
727
66
    ret = cos(num);
728
66
    return(ret);
729
181
}
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
199
exsltMathCosFunction (xmlXPathParserContextPtr ctxt, int nargs) {
740
199
    double ret;
741
742
199
    if (nargs != 1) {
743
18
  xmlXPathSetArityError(ctxt);
744
18
  return;
745
18
    }
746
181
    ret = xmlXPathPopNumber(ctxt);
747
181
    if (xmlXPathCheckError(ctxt))
748
0
  return;
749
750
181
    ret = exsltMathCos(ret);
751
752
181
    xmlXPathReturnNumber(ctxt, ret);
753
181
}
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
70
exsltMathTan (double num) {
766
70
    double ret;
767
768
70
    if (xmlXPathIsNaN(num))
769
38
  return(xmlXPathNAN);
770
32
    ret = tan(num);
771
32
    return(ret);
772
70
}
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
87
exsltMathTanFunction (xmlXPathParserContextPtr ctxt, int nargs) {
783
87
    double ret;
784
785
87
    if (nargs != 1) {
786
17
  xmlXPathSetArityError(ctxt);
787
17
  return;
788
17
    }
789
70
    ret = xmlXPathPopNumber(ctxt);
790
70
    if (xmlXPathCheckError(ctxt))
791
0
  return;
792
793
70
    ret = exsltMathTan(ret);
794
795
70
    xmlXPathReturnNumber(ctxt, ret);
796
70
}
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
68
exsltMathAsin (double num) {
809
68
    double ret;
810
811
68
    if (xmlXPathIsNaN(num))
812
31
  return(xmlXPathNAN);
813
37
    ret = asin(num);
814
37
    return(ret);
815
68
}
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
78
exsltMathAsinFunction (xmlXPathParserContextPtr ctxt, int nargs) {
826
78
    double ret;
827
828
78
    if (nargs != 1) {
829
10
  xmlXPathSetArityError(ctxt);
830
10
  return;
831
10
    }
832
68
    ret = xmlXPathPopNumber(ctxt);
833
68
    if (xmlXPathCheckError(ctxt))
834
0
  return;
835
836
68
    ret = exsltMathAsin(ret);
837
838
68
    xmlXPathReturnNumber(ctxt, ret);
839
68
}
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
62
exsltMathAcos (double num) {
852
62
    double ret;
853
854
62
    if (xmlXPathIsNaN(num))
855
31
  return(xmlXPathNAN);
856
31
    ret = acos(num);
857
31
    return(ret);
858
62
}
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
79
exsltMathAcosFunction (xmlXPathParserContextPtr ctxt, int nargs) {
869
79
    double ret;
870
871
79
    if (nargs != 1) {
872
17
  xmlXPathSetArityError(ctxt);
873
17
  return;
874
17
    }
875
62
    ret = xmlXPathPopNumber(ctxt);
876
62
    if (xmlXPathCheckError(ctxt))
877
0
  return;
878
879
62
    ret = exsltMathAcos(ret);
880
881
62
    xmlXPathReturnNumber(ctxt, ret);
882
62
}
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
72
exsltMathAtan (double num) {
895
72
    double ret;
896
897
72
    if (xmlXPathIsNaN(num))
898
48
  return(xmlXPathNAN);
899
24
    ret = atan(num);
900
24
    return(ret);
901
72
}
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
91
exsltMathAtanFunction (xmlXPathParserContextPtr ctxt, int nargs) {
912
91
    double ret;
913
914
91
    if (nargs != 1) {
915
19
  xmlXPathSetArityError(ctxt);
916
19
  return;
917
19
    }
918
72
    ret = xmlXPathPopNumber(ctxt);
919
72
    if (xmlXPathCheckError(ctxt))
920
0
  return;
921
922
72
    ret = exsltMathAtan(ret);
923
924
72
    xmlXPathReturnNumber(ctxt, ret);
925
72
}
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
123
exsltMathAtan2 (double y, double x) {
940
123
    double ret;
941
942
123
    if ((xmlXPathIsNaN(y) || xmlXPathIsNaN(x)))
943
91
  return(xmlXPathNAN);
944
32
    ret = atan2(y, x);
945
32
    return(ret);
946
123
}
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
143
exsltMathAtan2Function (xmlXPathParserContextPtr ctxt, int nargs) {
957
143
    double ret, x;
958
959
143
    if (nargs != 2) {
960
20
  xmlXPathSetArityError(ctxt);
961
20
  return;
962
20
    }
963
123
    x = xmlXPathPopNumber(ctxt);
964
123
    if (xmlXPathCheckError(ctxt))
965
0
  return;
966
967
    /* y */
968
123
    ret = xmlXPathPopNumber(ctxt);
969
123
    if (xmlXPathCheckError(ctxt))
970
0
  return;
971
972
123
    ret = exsltMathAtan2(ret, x);
973
974
123
    xmlXPathReturnNumber(ctxt, ret);
975
123
}
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
100
exsltMathExp (double num) {
989
100
    double ret;
990
991
100
    if (xmlXPathIsNaN(num))
992
63
  return(xmlXPathNAN);
993
37
    ret = exp(num);
994
37
    return(ret);
995
100
}
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
116
exsltMathExpFunction (xmlXPathParserContextPtr ctxt, int nargs) {
1006
116
    double ret;
1007
1008
116
    if (nargs != 1) {
1009
16
  xmlXPathSetArityError(ctxt);
1010
16
  return;
1011
16
    }
1012
100
    ret = xmlXPathPopNumber(ctxt);
1013
100
    if (xmlXPathCheckError(ctxt))
1014
0
  return;
1015
1016
100
    ret = exsltMathExp(ret);
1017
1018
100
    xmlXPathReturnNumber(ctxt, ret);
1019
100
}
1020
1021
/**
1022
 * exsltMathRegister:
1023
 *
1024
 * Registers the EXSLT - Math module
1025
 */
1026
1027
void
1028
2.98k
exsltMathRegister (void) {
1029
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "min",
1030
2.98k
           EXSLT_MATH_NAMESPACE,
1031
2.98k
           exsltMathMinFunction);
1032
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "max",
1033
2.98k
           EXSLT_MATH_NAMESPACE,
1034
2.98k
           exsltMathMaxFunction);
1035
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "highest",
1036
2.98k
           EXSLT_MATH_NAMESPACE,
1037
2.98k
           exsltMathHighestFunction);
1038
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "lowest",
1039
2.98k
           EXSLT_MATH_NAMESPACE,
1040
2.98k
           exsltMathLowestFunction);
1041
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "constant",
1042
2.98k
           EXSLT_MATH_NAMESPACE,
1043
2.98k
           exsltMathConstantFunction);
1044
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "random",
1045
2.98k
           EXSLT_MATH_NAMESPACE,
1046
2.98k
           exsltMathRandomFunction);
1047
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "abs",
1048
2.98k
           EXSLT_MATH_NAMESPACE,
1049
2.98k
           exsltMathAbsFunction);
1050
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "sqrt",
1051
2.98k
           EXSLT_MATH_NAMESPACE,
1052
2.98k
           exsltMathSqrtFunction);
1053
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "power",
1054
2.98k
           EXSLT_MATH_NAMESPACE,
1055
2.98k
           exsltMathPowerFunction);
1056
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "log",
1057
2.98k
           EXSLT_MATH_NAMESPACE,
1058
2.98k
           exsltMathLogFunction);
1059
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "sin",
1060
2.98k
           EXSLT_MATH_NAMESPACE,
1061
2.98k
           exsltMathSinFunction);
1062
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "cos",
1063
2.98k
           EXSLT_MATH_NAMESPACE,
1064
2.98k
           exsltMathCosFunction);
1065
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "tan",
1066
2.98k
           EXSLT_MATH_NAMESPACE,
1067
2.98k
           exsltMathTanFunction);
1068
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "asin",
1069
2.98k
           EXSLT_MATH_NAMESPACE,
1070
2.98k
           exsltMathAsinFunction);
1071
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "acos",
1072
2.98k
           EXSLT_MATH_NAMESPACE,
1073
2.98k
           exsltMathAcosFunction);
1074
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "atan",
1075
2.98k
           EXSLT_MATH_NAMESPACE,
1076
2.98k
           exsltMathAtanFunction);
1077
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "atan2",
1078
2.98k
           EXSLT_MATH_NAMESPACE,
1079
2.98k
           exsltMathAtan2Function);
1080
2.98k
    xsltRegisterExtModuleFunction ((const xmlChar *) "exp",
1081
2.98k
           EXSLT_MATH_NAMESPACE,
1082
2.98k
           exsltMathExpFunction);
1083
2.98k
}
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
}