/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 | } |