dll/3rdparty/libxslt/functions.c

   1 /*
   2  * functions.c: Implementation of the XSLT extra functions
   3  *
   4  * Reference:
   5  *   http://www.w3.org/TR/1999/REC-xslt-19991116
   6  *
   7  * See Copyright for the status of this software.
   8  *
   9  * daniel@veillard.com
  10  * Bjorn Reese <breese@users.sourceforge.net> for number formatting
  11  */
  12
  13 #define IN_LIBXSLT
  14 #include "libxslt.h"
  15
  16 #include <string.h>
  17
  18 #ifdef HAVE_SYS_TYPES_H
  19 #include <sys/types.h>
  20 #endif
  21 #ifdef HAVE_CTYPE_H
  22 #include <ctype.h>
  23 #endif
  24
  25 #include <libxml/xmlmemory.h>
  26 #include <libxml/parser.h>
  27 #include <libxml/tree.h>
  28 #include <libxml/valid.h>
  29 #include <libxml/hash.h>
  30 #include <libxml/xmlerror.h>
  31 #include <libxml/xpath.h>
  32 #include <libxml/xpathInternals.h>
  33 #include <libxml/parserInternals.h>
  34 #include <libxml/uri.h>
  35 #include <libxml/xpointer.h>
  36 #include "xslt.h"
  37 #include "xsltInternals.h"
  38 #include "xsltutils.h"
  39 #include "functions.h"
  40 #include "extensions.h"
  41 #include "numbersInternals.h"
  42 #include "keys.h"
  43 #include "documents.h"
  44
  45 #ifdef WITH_XSLT_DEBUG
  46 #define WITH_XSLT_DEBUG_FUNCTION
  47 #endif
  48
  49 /*
  50  * Some versions of DocBook XSL use the vendor string to detect
  51  * supporting chunking, this is a workaround to be considered
  52  * in the list of decent XSLT processors <grin/>
  53  */
  54 #define DOCBOOK_XSL_HACK
  55
  56 /**
  57  * xsltXPathFunctionLookup:
  58  * @ctxt:  a void * but the XSLT transformation context actually
  59  * @name:  the function name
  60  * @ns_uri:  the function namespace URI
  61  *
  62  * This is the entry point when a function is needed by the XPath
  63  * interpretor.
  64  *
  65  * Returns the callback function or NULL if not found
  66  */
  67 xmlXPathFunction
  68 xsltXPathFunctionLookup (xmlXPathContextPtr ctxt,
  69                          const xmlChar *name, const xmlChar *ns_uri) {
  70     xmlXPathFunction ret;
  71
  72     if ((ctxt == NULL) || (name == NULL) || (ns_uri == NULL))
  73         return (NULL);
  74
  75 #ifdef WITH_XSLT_DEBUG_FUNCTION
  76     xsltGenericDebug(xsltGenericDebugContext,
  77             "Lookup function {%s}%s\n", ns_uri, name);
  78 #endif
  79
  80     /* give priority to context-level functions */
  81     /*
  82     ret = (xmlXPathFunction) xmlHashLookup2(ctxt->funcHash, name, ns_uri);
  83     */
  84     XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
  85
  86     if (ret == NULL)
  87         ret = xsltExtModuleFunctionLookup(name, ns_uri);
  88
  89 #ifdef WITH_XSLT_DEBUG_FUNCTION
  90     if (ret != NULL)
  91         xsltGenericDebug(xsltGenericDebugContext,
  92             "found function %s\n", name);
  93 #endif
  94     return(ret);
  95 }
  96
  97
  98 /************************************************************************
  99  *                                                                      *
 100  *                      Module interfaces                               *
 101  *                                                                      *
 102  ************************************************************************/
 103
 104 static void
 105 xsltDocumentFunctionLoadDocument(xmlXPathParserContextPtr ctxt, xmlChar* URI)
 106 {
 107     xsltTransformContextPtr tctxt;
 108     xmlURIPtr uri;
 109     xmlChar *fragment;
 110     xsltDocumentPtr idoc; /* document info */
 111     xmlDocPtr doc;
 112     xmlXPathContextPtr xptrctxt = NULL;
 113     xmlXPathObjectPtr resObj = NULL;
 114
 115     tctxt = xsltXPathGetTransformContext(ctxt);
 116     if (tctxt == NULL) {
 117         xsltTransformError(NULL, NULL, NULL,
 118             "document() : internal error tctxt == NULL\n");
 119         valuePush(ctxt, xmlXPathNewNodeSet(NULL));
 120         return;
 121     }
 122
 123     uri = xmlParseURI((const char *) URI);
 124     if (uri == NULL) {
 125         xsltTransformError(tctxt, NULL, NULL,
 126             "document() : failed to parse URI\n");
 127         valuePush(ctxt, xmlXPathNewNodeSet(NULL));
 128         return;
 129     }
 130
 131     /*
 132      * check for and remove fragment identifier
 133      */
 134     fragment = (xmlChar *)uri->fragment;
 135     if (fragment != NULL) {
 136         xmlChar *newURI;
 137         uri->fragment = NULL;
 138         newURI = xmlSaveUri(uri);
 139         idoc = xsltLoadDocument(tctxt, newURI);
 140         xmlFree(newURI);
 141     } else
 142         idoc = xsltLoadDocument(tctxt, URI);
 143     xmlFreeURI(uri);
 144
 145     if (idoc == NULL) {
 146         if ((URI == NULL) ||
 147             (URI[0] == '#') ||
 148             ((tctxt->style->doc != NULL) &&
 149             (xmlStrEqual(tctxt->style->doc->URL, URI))))
 150         {
 151             /*
 152             * This selects the stylesheet's doc itself.
 153             */
 154             doc = tctxt->style->doc;
 155         } else {
 156             valuePush(ctxt, xmlXPathNewNodeSet(NULL));
 157
 158             if (fragment != NULL)
 159                 xmlFree(fragment);
 160
 161             return;
 162         }
 163     } else
 164         doc = idoc->doc;
 165
 166     if (fragment == NULL) {
 167         valuePush(ctxt, xmlXPathNewNodeSet((xmlNodePtr) doc));
 168         return;
 169     }
 170
 171     /* use XPointer of HTML location for fragment ID */
 172 #ifdef LIBXML_XPTR_ENABLED
 173     xptrctxt = xmlXPtrNewContext(doc, NULL, NULL);
 174     if (xptrctxt == NULL) {
 175         xsltTransformError(tctxt, NULL, NULL,
 176             "document() : internal error xptrctxt == NULL\n");
 177         goto out_fragment;
 178     }
 179
 180     resObj = xmlXPtrEval(fragment, xptrctxt);
 181     xmlXPathFreeContext(xptrctxt);
 182 #endif
 183     xmlFree(fragment);
 184
 185     if (resObj == NULL)
 186         goto out_fragment;
 187
 188     switch (resObj->type) {
 189         case XPATH_NODESET:
 190             break;
 191         case XPATH_UNDEFINED:
 192         case XPATH_BOOLEAN:
 193         case XPATH_NUMBER:
 194         case XPATH_STRING:
 195         case XPATH_POINT:
 196         case XPATH_USERS:
 197         case XPATH_XSLT_TREE:
 198         case XPATH_RANGE:
 199         case XPATH_LOCATIONSET:
 200             xsltTransformError(tctxt, NULL, NULL,
 201                 "document() : XPointer does not select a node set: #%s\n",
 202                 fragment);
 203         goto out_object;
 204     }
 205
 206     valuePush(ctxt, resObj);
 207     return;
 208
 209 out_object:
 210     xmlXPathFreeObject(resObj);
 211
 212 out_fragment:
 213     valuePush(ctxt, xmlXPathNewNodeSet(NULL));
 214 }
 215
 216 /**
 217  * xsltDocumentFunction:
 218  * @ctxt:  the XPath Parser context
 219  * @nargs:  the number of arguments
 220  *
 221  * Implement the document() XSLT function
 222  *   node-set document(object, node-set?)
 223  */
 224 void
 225 xsltDocumentFunction(xmlXPathParserContextPtr ctxt, int nargs)
 226 {
 227     xmlXPathObjectPtr obj, obj2 = NULL;
 228     xmlChar *base = NULL, *URI;
 229
 230
 231     if ((nargs < 1) || (nargs > 2)) {
 232         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 233                          "document() : invalid number of args %d\n",
 234                          nargs);
 235         ctxt->error = XPATH_INVALID_ARITY;
 236         return;
 237     }
 238     if (ctxt->value == NULL) {
 239         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 240                          "document() : invalid arg value\n");
 241         ctxt->error = XPATH_INVALID_TYPE;
 242         return;
 243     }
 244
 245     if (nargs == 2) {
 246         if (ctxt->value->type != XPATH_NODESET) {
 247             xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 248                              "document() : invalid arg expecting a nodeset\n");
 249             ctxt->error = XPATH_INVALID_TYPE;
 250             return;
 251         }
 252
 253         obj2 = valuePop(ctxt);
 254     }
 255
 256     if (ctxt->value->type == XPATH_NODESET) {
 257         int i;
 258         xmlXPathObjectPtr newobj, ret;
 259
 260         obj = valuePop(ctxt);
 261         ret = xmlXPathNewNodeSet(NULL);
 262
 263         if (obj->nodesetval) {
 264             for (i = 0; i < obj->nodesetval->nodeNr; i++) {
 265                 valuePush(ctxt,
 266                           xmlXPathNewNodeSet(obj->nodesetval->nodeTab[i]));
 267                 xmlXPathStringFunction(ctxt, 1);
 268                 if (nargs == 2) {
 269                     valuePush(ctxt, xmlXPathObjectCopy(obj2));
 270                 } else {
 271                     valuePush(ctxt,
 272                               xmlXPathNewNodeSet(obj->nodesetval->
 273                                                  nodeTab[i]));
 274                 }
 275                 xsltDocumentFunction(ctxt, 2);
 276                 newobj = valuePop(ctxt);
 277                 ret->nodesetval = xmlXPathNodeSetMerge(ret->nodesetval,
 278                                                        newobj->nodesetval);
 279                 xmlXPathFreeObject(newobj);
 280             }
 281         }
 282
 283         xmlXPathFreeObject(obj);
 284         if (obj2 != NULL)
 285             xmlXPathFreeObject(obj2);
 286         valuePush(ctxt, ret);
 287         return;
 288     }
 289     /*
 290      * Make sure it's converted to a string
 291      */
 292     xmlXPathStringFunction(ctxt, 1);
 293     if (ctxt->value->type != XPATH_STRING) {
 294         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 295                          "document() : invalid arg expecting a string\n");
 296         ctxt->error = XPATH_INVALID_TYPE;
 297         if (obj2 != NULL)
 298             xmlXPathFreeObject(obj2);
 299         return;
 300     }
 301     obj = valuePop(ctxt);
 302     if (obj->stringval == NULL) {
 303         valuePush(ctxt, xmlXPathNewNodeSet(NULL));
 304     } else {
 305         if ((obj2 != NULL) && (obj2->nodesetval != NULL) &&
 306             (obj2->nodesetval->nodeNr > 0) &&
 307             IS_XSLT_REAL_NODE(obj2->nodesetval->nodeTab[0])) {
 308             xmlNodePtr target;
 309
 310             target = obj2->nodesetval->nodeTab[0];
 311             if ((target->type == XML_ATTRIBUTE_NODE) ||
 312                 (target->type == XML_PI_NODE)) {
 313                 target = ((xmlAttrPtr) target)->parent;
 314             }
 315             base = xmlNodeGetBase(target->doc, target);
 316         } else {
 317             xsltTransformContextPtr tctxt;
 318
 319             tctxt = xsltXPathGetTransformContext(ctxt);
 320             if ((tctxt != NULL) && (tctxt->inst != NULL)) {
 321                 base = xmlNodeGetBase(tctxt->inst->doc, tctxt->inst);
 322             } else if ((tctxt != NULL) && (tctxt->style != NULL) &&
 323                        (tctxt->style->doc != NULL)) {
 324                 base = xmlNodeGetBase(tctxt->style->doc,
 325                                       (xmlNodePtr) tctxt->style->doc);
 326             }
 327         }
 328         URI = xmlBuildURI(obj->stringval, base);
 329         if (base != NULL)
 330             xmlFree(base);
 331         if (URI == NULL) {
 332             valuePush(ctxt, xmlXPathNewNodeSet(NULL));
 333         } else {
 334             xsltDocumentFunctionLoadDocument( ctxt, URI );
 335             xmlFree(URI);
 336         }
 337     }
 338     xmlXPathFreeObject(obj);
 339     if (obj2 != NULL)
 340         xmlXPathFreeObject(obj2);
 341 }
 342
 343 /**
 344  * xsltKeyFunction:
 345  * @ctxt:  the XPath Parser context
 346  * @nargs:  the number of arguments
 347  *
 348  * Implement the key() XSLT function
 349  *   node-set key(string, object)
 350  */
 351 void
 352 xsltKeyFunction(xmlXPathParserContextPtr ctxt, int nargs){
 353     xmlXPathObjectPtr obj1, obj2;
 354
 355     if (nargs != 2) {
 356         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 357                 "key() : expects two arguments\n");
 358         ctxt->error = XPATH_INVALID_ARITY;
 359         return;
 360     }
 361
 362     /*
 363     * Get the key's value.
 364     */
 365     obj2 = valuePop(ctxt);
 366     xmlXPathStringFunction(ctxt, 1);
 367     if ((obj2 == NULL) ||
 368         (ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
 369         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 370             "key() : invalid arg expecting a string\n");
 371         ctxt->error = XPATH_INVALID_TYPE;
 372         xmlXPathFreeObject(obj2);
 373
 374         return;
 375     }
 376     /*
 377     * Get the key's name.
 378     */
 379     obj1 = valuePop(ctxt);
 380
 381     if ((obj2->type == XPATH_NODESET) || (obj2->type == XPATH_XSLT_TREE)) {
 382         int i;
 383         xmlXPathObjectPtr newobj, ret;
 384
 385         ret = xmlXPathNewNodeSet(NULL);
 386
 387         if (obj2->nodesetval != NULL) {
 388             for (i = 0; i < obj2->nodesetval->nodeNr; i++) {
 389                 valuePush(ctxt, xmlXPathObjectCopy(obj1));
 390                 valuePush(ctxt,
 391                           xmlXPathNewNodeSet(obj2->nodesetval->nodeTab[i]));
 392                 xmlXPathStringFunction(ctxt, 1);
 393                 xsltKeyFunction(ctxt, 2);
 394                 newobj = valuePop(ctxt);
 395                 ret->nodesetval = xmlXPathNodeSetMerge(ret->nodesetval,
 396                                                        newobj->nodesetval);
 397                 xmlXPathFreeObject(newobj);
 398             }
 399         }
 400         valuePush(ctxt, ret);
 401     } else {
 402         xmlNodeSetPtr nodelist = NULL;
 403         xmlChar *key = NULL, *value;
 404         const xmlChar *keyURI;
 405         xsltTransformContextPtr tctxt;
 406         xmlChar *qname, *prefix;
 407         xmlXPathContextPtr xpctxt = ctxt->context;
 408         xmlNodePtr tmpNode = NULL;
 409         xsltDocumentPtr oldDocInfo;
 410
 411         tctxt = xsltXPathGetTransformContext(ctxt);
 412
 413         oldDocInfo = tctxt->document;
 414
 415         if (xpctxt->node == NULL) {
 416             xsltTransformError(tctxt, NULL, tctxt->inst,
 417                 "Internal error in xsltKeyFunction(): "
 418                 "The context node is not set on the XPath context.\n");
 419             tctxt->state = XSLT_STATE_STOPPED;
 420             goto error;
 421         }
 422         /*
 423          * Get the associated namespace URI if qualified name
 424          */
 425         qname = obj1->stringval;
 426         key = xmlSplitQName2(qname, &prefix);
 427         if (key == NULL) {
 428             key = xmlStrdup(obj1->stringval);
 429             keyURI = NULL;
 430             if (prefix != NULL)
 431                 xmlFree(prefix);
 432         } else {
 433             if (prefix != NULL) {
 434                 keyURI = xmlXPathNsLookup(xpctxt, prefix);
 435                 if (keyURI == NULL) {
 436                     xsltTransformError(tctxt, NULL, tctxt->inst,
 437                         "key() : prefix %s is not bound\n", prefix);
 438                     /*
 439                     * TODO: Shouldn't we stop here?
 440                     */
 441                 }
 442                 xmlFree(prefix);
 443             } else {
 444                 keyURI = NULL;
 445             }
 446         }
 447
 448         /*
 449          * Force conversion of first arg to string
 450          */
 451         valuePush(ctxt, obj2);
 452         xmlXPathStringFunction(ctxt, 1);
 453         if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
 454             xsltTransformError(tctxt, NULL, tctxt->inst,
 455                 "key() : invalid arg expecting a string\n");
 456             ctxt->error = XPATH_INVALID_TYPE;
 457             goto error;
 458         }
 459         obj2 = valuePop(ctxt);
 460         value = obj2->stringval;
 461
 462         /*
 463         * We need to ensure that ctxt->document is available for
 464         * xsltGetKey().
 465         * First find the relevant doc, which is the context node's
 466         * owner doc; using context->doc is not safe, since
 467         * the doc could have been acquired via the document() function,
 468         * or the doc might be a Result Tree Fragment.
 469         * FUTURE INFO: In XSLT 2.0 the key() function takes an additional
 470         * argument indicating the doc to use.
 471         */
 472         if (xpctxt->node->type == XML_NAMESPACE_DECL) {
 473             /*
 474             * REVISIT: This is a libxml hack! Check xpath.c for details.
 475             * The XPath module sets the owner element of a ns-node on
 476             * the ns->next field.
 477             */
 478             if ((((xmlNsPtr) xpctxt->node)->next != NULL) &&
 479                 (((xmlNsPtr) xpctxt->node)->next->type == XML_ELEMENT_NODE))
 480             {
 481                 tmpNode = (xmlNodePtr) ((xmlNsPtr) xpctxt->node)->next;
 482             }
 483         } else
 484             tmpNode = xpctxt->node;
 485
 486         if ((tmpNode == NULL) || (tmpNode->doc == NULL)) {
 487             xsltTransformError(tctxt, NULL, tctxt->inst,
 488                 "Internal error in xsltKeyFunction(): "
 489                 "Couldn't get the doc of the XPath context node.\n");
 490             goto error;
 491         }
 492
 493         if ((tctxt->document == NULL) ||
 494             (tctxt->document->doc != tmpNode->doc))
 495         {
 496             if (tmpNode->doc->name && (tmpNode->doc->name[0] == ' ')) {
 497                 /*
 498                 * This is a Result Tree Fragment.
 499                 */
 500                 if (tmpNode->doc->_private == NULL) {
 501                     tmpNode->doc->_private = xsltNewDocument(tctxt, tmpNode->doc);
 502                     if (tmpNode->doc->_private == NULL)
 503                         goto error;
 504                 }
 505                 tctxt->document = (xsltDocumentPtr) tmpNode->doc->_private;
 506             } else {
 507                 /*
 508                 * May be the initial source doc or a doc acquired via the
 509                 * document() function.
 510                 */
 511                 tctxt->document = xsltFindDocument(tctxt, tmpNode->doc);
 512             }
 513             if (tctxt->document == NULL) {
 514                 xsltTransformError(tctxt, NULL, tctxt->inst,
 515                     "Internal error in xsltKeyFunction(): "
 516                     "Could not get the document info of a context doc.\n");
 517                 tctxt->state = XSLT_STATE_STOPPED;
 518                 goto error;
 519             }
 520         }
 521         /*
 522         * Get/compute the key value.
 523         */
 524         nodelist = xsltGetKey(tctxt, key, keyURI, value);
 525
 526 error:
 527         tctxt->document = oldDocInfo;
 528         valuePush(ctxt, xmlXPathWrapNodeSet(
 529             xmlXPathNodeSetMerge(NULL, nodelist)));
 530         if (key != NULL)
 531             xmlFree(key);
 532     }
 533
 534     if (obj1 != NULL)
 535         xmlXPathFreeObject(obj1);
 536     if (obj2 != NULL)
 537         xmlXPathFreeObject(obj2);
 538 }
 539
 540 /**
 541  * xsltUnparsedEntityURIFunction:
 542  * @ctxt:  the XPath Parser context
 543  * @nargs:  the number of arguments
 544  *
 545  * Implement the unparsed-entity-uri() XSLT function
 546  *   string unparsed-entity-uri(string)
 547  */
 548 void
 549 xsltUnparsedEntityURIFunction(xmlXPathParserContextPtr ctxt, int nargs){
 550     xmlXPathObjectPtr obj;
 551     xmlChar *str;
 552
 553     if ((nargs != 1) || (ctxt->value == NULL)) {
 554         xsltGenericError(xsltGenericErrorContext,
 555                 "unparsed-entity-uri() : expects one string arg\n");
 556         ctxt->error = XPATH_INVALID_ARITY;
 557         return;
 558     }
 559     obj = valuePop(ctxt);
 560     if (obj->type != XPATH_STRING) {
 561         obj = xmlXPathConvertString(obj);
 562     }
 563
 564     str = obj->stringval;
 565     if (str == NULL) {
 566         valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
 567     } else {
 568         xmlEntityPtr entity;
 569
 570         entity = xmlGetDocEntity(ctxt->context->doc, str);
 571         if (entity == NULL) {
 572             valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
 573         } else {
 574             if (entity->URI != NULL)
 575                 valuePush(ctxt, xmlXPathNewString(entity->URI));
 576             else
 577                 valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
 578         }
 579     }
 580     xmlXPathFreeObject(obj);
 581 }
 582
 583 /**
 584  * xsltFormatNumberFunction:
 585  * @ctxt:  the XPath Parser context
 586  * @nargs:  the number of arguments
 587  *
 588  * Implement the format-number() XSLT function
 589  *   string format-number(number, string, string?)
 590  */
 591 void
 592 xsltFormatNumberFunction(xmlXPathParserContextPtr ctxt, int nargs)
 593 {
 594     xmlXPathObjectPtr numberObj = NULL;
 595     xmlXPathObjectPtr formatObj = NULL;
 596     xmlXPathObjectPtr decimalObj = NULL;
 597     xsltStylesheetPtr sheet;
 598     xsltDecimalFormatPtr formatValues;
 599     xmlChar *result;
 600     xsltTransformContextPtr tctxt;
 601
 602     tctxt = xsltXPathGetTransformContext(ctxt);
 603     if (tctxt == NULL)
 604         return;
 605     sheet = tctxt->style;
 606     if (sheet == NULL)
 607         return;
 608     formatValues = sheet->decimalFormat;
 609
 610     switch (nargs) {
 611     case 3:
 612         CAST_TO_STRING;
 613         decimalObj = valuePop(ctxt);
 614         formatValues = xsltDecimalFormatGetByName(sheet, decimalObj->stringval);
 615         if (formatValues == NULL) {
 616             xsltTransformError(tctxt, NULL, NULL,
 617                     "format-number() : undeclared decimal format '%s'\n",
 618                     decimalObj->stringval);
 619         }
 620         /* Intentional fall-through */
 621     case 2:
 622         CAST_TO_STRING;
 623         formatObj = valuePop(ctxt);
 624         CAST_TO_NUMBER;
 625         numberObj = valuePop(ctxt);
 626         break;
 627     default:
 628         XP_ERROR(XPATH_INVALID_ARITY);
 629     }
 630
 631     if (formatValues != NULL) {
 632         if (xsltFormatNumberConversion(formatValues,
 633                                        formatObj->stringval,
 634                                        numberObj->floatval,
 635                                        &result) == XPATH_EXPRESSION_OK) {
 636             valuePush(ctxt, xmlXPathNewString(result));
 637             xmlFree(result);
 638         }
 639     }
 640
 641     xmlXPathFreeObject(numberObj);
 642     xmlXPathFreeObject(formatObj);
 643     xmlXPathFreeObject(decimalObj);
 644 }
 645
 646 /**
 647  * xsltGenerateIdFunction:
 648  * @ctxt:  the XPath Parser context
 649  * @nargs:  the number of arguments
 650  *
 651  * Implement the generate-id() XSLT function
 652  *   string generate-id(node-set?)
 653  */
 654 void
 655 xsltGenerateIdFunction(xmlXPathParserContextPtr ctxt, int nargs){
 656     xmlNodePtr cur = NULL;
 657     unsigned long val;
 658     xmlChar str[20];
 659
 660     if (nargs == 0) {
 661         cur = ctxt->context->node;
 662     } else if (nargs == 1) {
 663         xmlXPathObjectPtr obj;
 664         xmlNodeSetPtr nodelist;
 665         int i, ret;
 666
 667         if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_NODESET)) {
 668             ctxt->error = XPATH_INVALID_TYPE;
 669             xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 670                 "generate-id() : invalid arg expecting a node-set\n");
 671             return;
 672         }
 673         obj = valuePop(ctxt);
 674         nodelist = obj->nodesetval;
 675         if ((nodelist == NULL) || (nodelist->nodeNr <= 0)) {
 676             xmlXPathFreeObject(obj);
 677             valuePush(ctxt, xmlXPathNewCString(""));
 678             return;
 679         }
 680         cur = nodelist->nodeTab[0];
 681         for (i = 1;i < nodelist->nodeNr;i++) {
 682             ret = xmlXPathCmpNodes(cur, nodelist->nodeTab[i]);
 683             if (ret == -1)
 684                 cur = nodelist->nodeTab[i];
 685         }
 686         xmlXPathFreeObject(obj);
 687     } else {
 688         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 689                 "generate-id() : invalid number of args %d\n", nargs);
 690         ctxt->error = XPATH_INVALID_ARITY;
 691         return;
 692     }
 693     /*
 694      * Okay this is ugly but should work, use the NodePtr address
 695      * to forge the ID
 696      */
 697     val = (unsigned long)((char *)cur - (char *)0);
 698     val /= sizeof(xmlNode);
 699     sprintf((char *)str, "id%ld", val);
 700     valuePush(ctxt, xmlXPathNewString(str));
 701 }
 702
 703 /**
 704  * xsltSystemPropertyFunction:
 705  * @ctxt:  the XPath Parser context
 706  * @nargs:  the number of arguments
 707  *
 708  * Implement the system-property() XSLT function
 709  *   object system-property(string)
 710  */
 711 void
 712 xsltSystemPropertyFunction(xmlXPathParserContextPtr ctxt, int nargs){
 713     xmlXPathObjectPtr obj;
 714     xmlChar *prefix, *name;
 715     const xmlChar *nsURI = NULL;
 716
 717     if (nargs != 1) {
 718         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 719                 "system-property() : expects one string arg\n");
 720         ctxt->error = XPATH_INVALID_ARITY;
 721         return;
 722     }
 723     if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
 724         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 725             "system-property() : invalid arg expecting a string\n");
 726         ctxt->error = XPATH_INVALID_TYPE;
 727         return;
 728     }
 729     obj = valuePop(ctxt);
 730     if (obj->stringval == NULL) {
 731         valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
 732     } else {
 733         name = xmlSplitQName2(obj->stringval, &prefix);
 734         if (name == NULL) {
 735             name = xmlStrdup(obj->stringval);
 736         } else {
 737             nsURI = xmlXPathNsLookup(ctxt->context, prefix);
 738             if (nsURI == NULL) {
 739                 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 740                     "system-property() : prefix %s is not bound\n", prefix);
 741             }
 742         }
 743
 744         if (xmlStrEqual(nsURI, XSLT_NAMESPACE)) {
 745 #ifdef DOCBOOK_XSL_HACK
 746             if (xmlStrEqual(name, (const xmlChar *)"vendor")) {
 747                 xsltStylesheetPtr sheet;
 748                 xsltTransformContextPtr tctxt;
 749
 750                 tctxt = xsltXPathGetTransformContext(ctxt);
 751                 if ((tctxt != NULL) && (tctxt->inst != NULL) &&
 752                     (xmlStrEqual(tctxt->inst->name, BAD_CAST "variable")) &&
 753                     (tctxt->inst->parent != NULL) &&
 754                     (xmlStrEqual(tctxt->inst->parent->name,
 755                                  BAD_CAST "template")))
 756                     sheet = tctxt->style;
 757                 else
 758                     sheet = NULL;
 759                 if ((sheet != NULL) && (sheet->doc != NULL) &&
 760                     (sheet->doc->URL != NULL) &&
 761                     (xmlStrstr(sheet->doc->URL,
 762                                (const xmlChar *)"chunk") != NULL)) {
 763                     valuePush(ctxt, xmlXPathNewString(
 764                         (const xmlChar *)"libxslt (SAXON 6.2 compatible)"));
 765
 766                 } else {
 767                     valuePush(ctxt, xmlXPathNewString(
 768                         (const xmlChar *)XSLT_DEFAULT_VENDOR));
 769                 }
 770             } else
 771 #else
 772             if (xmlStrEqual(name, (const xmlChar *)"vendor")) {
 773                 valuePush(ctxt, xmlXPathNewString(
 774                           (const xmlChar *)XSLT_DEFAULT_VENDOR));
 775             } else
 776 #endif
 777             if (xmlStrEqual(name, (const xmlChar *)"version")) {
 778                 valuePush(ctxt, xmlXPathNewString(
 779                     (const xmlChar *)XSLT_DEFAULT_VERSION));
 780             } else if (xmlStrEqual(name, (const xmlChar *)"vendor-url")) {
 781                 valuePush(ctxt, xmlXPathNewString(
 782                     (const xmlChar *)XSLT_DEFAULT_URL));
 783             } else {
 784                 valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
 785             }
 786         }
 787         if (name != NULL)
 788             xmlFree(name);
 789         if (prefix != NULL)
 790             xmlFree(prefix);
 791     }
 792     xmlXPathFreeObject(obj);
 793 }
 794
 795 /**
 796  * xsltElementAvailableFunction:
 797  * @ctxt:  the XPath Parser context
 798  * @nargs:  the number of arguments
 799  *
 800  * Implement the element-available() XSLT function
 801  *   boolean element-available(string)
 802  */
 803 void
 804 xsltElementAvailableFunction(xmlXPathParserContextPtr ctxt, int nargs){
 805     xmlXPathObjectPtr obj;
 806     xmlChar *prefix, *name;
 807     const xmlChar *nsURI = NULL;
 808     xsltTransformContextPtr tctxt;
 809
 810     if (nargs != 1) {
 811         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 812                 "element-available() : expects one string arg\n");
 813         ctxt->error = XPATH_INVALID_ARITY;
 814         return;
 815     }
 816     xmlXPathStringFunction(ctxt, 1);
 817     if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
 818         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 819             "element-available() : invalid arg expecting a string\n");
 820         ctxt->error = XPATH_INVALID_TYPE;
 821         return;
 822     }
 823     obj = valuePop(ctxt);
 824     tctxt = xsltXPathGetTransformContext(ctxt);
 825     if (tctxt == NULL) {
 826         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 827                 "element-available() : internal error tctxt == NULL\n");
 828         xmlXPathFreeObject(obj);
 829         valuePush(ctxt, xmlXPathNewBoolean(0));
 830         return;
 831     }
 832
 833
 834     name = xmlSplitQName2(obj->stringval, &prefix);
 835     if (name == NULL) {
 836         xmlNsPtr ns;
 837
 838         name = xmlStrdup(obj->stringval);
 839         ns = xmlSearchNs(tctxt->inst->doc, tctxt->inst, NULL);
 840         if (ns != NULL) nsURI = xmlStrdup(ns->href);
 841     } else {
 842         nsURI = xmlXPathNsLookup(ctxt->context, prefix);
 843         if (nsURI == NULL) {
 844             xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 845                 "element-available() : prefix %s is not bound\n", prefix);
 846         }
 847     }
 848
 849     if (xsltExtElementLookup(tctxt, name, nsURI) != NULL) {
 850         valuePush(ctxt, xmlXPathNewBoolean(1));
 851     } else {
 852         valuePush(ctxt, xmlXPathNewBoolean(0));
 853     }
 854
 855     xmlXPathFreeObject(obj);
 856     if (name != NULL)
 857         xmlFree(name);
 858     if (prefix != NULL)
 859         xmlFree(prefix);
 860 }
 861
 862 /**
 863  * xsltFunctionAvailableFunction:
 864  * @ctxt:  the XPath Parser context
 865  * @nargs:  the number of arguments
 866  *
 867  * Implement the function-available() XSLT function
 868  *   boolean function-available(string)
 869  */
 870 void
 871 xsltFunctionAvailableFunction(xmlXPathParserContextPtr ctxt, int nargs){
 872     xmlXPathObjectPtr obj;
 873     xmlChar *prefix, *name;
 874     const xmlChar *nsURI = NULL;
 875
 876     if (nargs != 1) {
 877         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 878                 "function-available() : expects one string arg\n");
 879         ctxt->error = XPATH_INVALID_ARITY;
 880         return;
 881     }
 882     xmlXPathStringFunction(ctxt, 1);
 883     if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
 884         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 885             "function-available() : invalid arg expecting a string\n");
 886         ctxt->error = XPATH_INVALID_TYPE;
 887         return;
 888     }
 889     obj = valuePop(ctxt);
 890
 891     name = xmlSplitQName2(obj->stringval, &prefix);
 892     if (name == NULL) {
 893         name = xmlStrdup(obj->stringval);
 894     } else {
 895         nsURI = xmlXPathNsLookup(ctxt->context, prefix);
 896         if (nsURI == NULL) {
 897             xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 898                 "function-available() : prefix %s is not bound\n", prefix);
 899         }
 900     }
 901
 902     if (xmlXPathFunctionLookupNS(ctxt->context, name, nsURI) != NULL) {
 903         valuePush(ctxt, xmlXPathNewBoolean(1));
 904     } else {
 905         valuePush(ctxt, xmlXPathNewBoolean(0));
 906     }
 907
 908     xmlXPathFreeObject(obj);
 909     if (name != NULL)
 910         xmlFree(name);
 911     if (prefix != NULL)
 912         xmlFree(prefix);
 913 }
 914
 915 /**
 916  * xsltCurrentFunction:
 917  * @ctxt:  the XPath Parser context
 918  * @nargs:  the number of arguments
 919  *
 920  * Implement the current() XSLT function
 921  *   node-set current()
 922  */
 923 static void
 924 xsltCurrentFunction(xmlXPathParserContextPtr ctxt, int nargs){
 925     xsltTransformContextPtr tctxt;
 926
 927     if (nargs != 0) {
 928         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 929                 "current() : function uses no argument\n");
 930         ctxt->error = XPATH_INVALID_ARITY;
 931         return;
 932     }
 933     tctxt = xsltXPathGetTransformContext(ctxt);
 934     if (tctxt == NULL) {
 935         xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
 936                 "current() : internal error tctxt == NULL\n");
 937         valuePush(ctxt, xmlXPathNewNodeSet(NULL));
 938     } else {
 939         valuePush(ctxt, xmlXPathNewNodeSet(tctxt->node)); /* current */
 940     }
 941 }
 942
 943 /************************************************************************
 944  *                                                                      *
 945  *              Registration of XSLT and libxslt functions              *
 946  *                                                                      *
 947  ************************************************************************/
 948
 949 /**
 950  * xsltRegisterAllFunctions:
 951  * @ctxt:  the XPath context
 952  *
 953  * Registers all default XSLT functions in this context
 954  */
 955 void
 956 xsltRegisterAllFunctions(xmlXPathContextPtr ctxt)
 957 {
 958     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "current",
 959                          xsltCurrentFunction);
 960     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "document",
 961                          xsltDocumentFunction);
 962     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "key", xsltKeyFunction);
 963     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "unparsed-entity-uri",
 964                          xsltUnparsedEntityURIFunction);
 965     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "format-number",
 966                          xsltFormatNumberFunction);
 967     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "generate-id",
 968                          xsltGenerateIdFunction);
 969     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "system-property",
 970                          xsltSystemPropertyFunction);
 971     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "element-available",
 972                          xsltElementAvailableFunction);
 973     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "function-available",
 974                          xsltFunctionAvailableFunction);
 975 }