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