third_party/libxslt/libexslt/math.c

   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 }