Include dependency graph for transform.c:
Go to the source code of this file.
Classes | |
| struct | xsltHTMLVersion |
Macros | |
| #define | XSLT_GENERATE_HTML_DOCTYPE |
| #define | FALSE (0 == 1) |
| #define | TRUE (!FALSE) |
| #define | IS_BLANK_NODE(n) (((n)->type == XML_TEXT_NODE) && (xsltIsBlank((n)->content))) |
Typedefs | |
| typedef struct xsltHTMLVersion | xsltHTMLVersion |
Variables | |
| int | xsltMaxDepth = 3000 |
| int | xsltMaxVars = 15000 |
| static int | xsltDoXIncludeDefault = 0 |
| static unsigned long | xsltDefaultTrace = (unsigned long) XSLT_TRACE_ALL |
| static xsltHTMLVersion | xsltHTMLVersions [] |
Macro Definition Documentation
◆ FALSE
| #define FALSE (0 == 1) |
Definition at line 43 of file transform.c.
◆ IS_BLANK_NODE
| #define IS_BLANK_NODE | ( | n | ) | (((n)->type == XML_TEXT_NODE) && (xsltIsBlank((n)->content))) |
Definition at line 47 of file transform.c.
◆ TRUE
Definition at line 44 of file transform.c.
◆ XSLT_GENERATE_HTML_DOCTYPE
| #define XSLT_GENERATE_HTML_DOCTYPE |
Definition at line 29 of file transform.c.
Typedef Documentation
◆ xsltHTMLVersion
| typedef struct xsltHTMLVersion xsltHTMLVersion |
Function Documentation
◆ templPop()
|
static |
templPop: @ctxt: the transformation context
Pop a template value from the stack
Returns the stored template value
Definition at line 121 of file transform.c.
Referenced by xsltApplyXSLTTemplate().
◆ templPush()
|
static |
templPush: @ctxt: the transformation context @value: the template to push on the stack
Push a template on the stack
Returns the new index in the stack or 0 in case of error
Definition at line 85 of file transform.c.
86{
88 ctxt->templMax = 4;
89 ctxt->templTab =
94 return (0);
95 }
96 }
98 ctxt->templMax *= 2;
99 ctxt->templTab =
101 ctxt->templMax *
105 return (0);
106 }
107 }
111}
Definition: pdh_main.c:94
Referenced by xsltApplyXSLTTemplate().
◆ xsltAddChild()
|
static |
xsltAddChild: @parent: the parent node @cur: the child node
Wrapper version of xmlAddChild with a more consistent behaviour on error. One expect the use to be child = xsltAddChild(parent, child); and the routine will take care of not leaking on errors or node merge
Returns the child is successfully attached or NULL if merged or freed
Definition at line 751 of file transform.c.
751 {
753
759 }
761
763}
XMLPUBFUN xmlNodePtr XMLCALL xmlAddChild(xmlNodePtr parent, xmlNodePtr cur)
XMLPUBFUN void XMLCALL xmlFreeNode(xmlNodePtr cur)
Definition: tree.h:489
Referenced by xsltApplySequenceConstructor(), xsltComment(), xsltCopy(), xsltCopyText(), xsltCopyTextString(), xsltCopyTree(), xsltElement(), xsltProcessingInstruction(), xsltShallowCopyElem(), and xsltText().
◆ xsltAddTextString()
|
static |
xsltAddTextString: @ctxt: a XSLT process context @target: the text node where the text will be attached @string: the text string @len: the string length in byte
Extend the current text node with the new string, it handles coalescing
Returns: the text node
Definition at line 777 of file transform.c.
778 {
779 /*
780 * optimization
781 */
784
786 int minSize;
787
788 /* Check for integer overflow accounting for NUL terminator. */
791 "xsltCopyText: text allocation failed\n");
793 }
795
797 xmlChar *newbuf;
800
801 /* Double buffer size but increase by at least 100 bytes. */
802 extra = minSize < 100 ? 100 : minSize;
803
804 /* Check for integer overflow. */
807 }
808 else {
810 }
811
815 "xsltCopyText: text allocation failed\n");
817 }
819 ctxt->lasttext = newbuf;
820 target->content = newbuf;
821 }
825 } else {
831 }
833}
XMLPUBFUN void XMLCALL xmlNodeAddContent(xmlNodePtr cur, const xmlChar *content)
void xsltTransformError(xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...)
Definition: xsltutils.c:678
Referenced by xsltCopyText(), and xsltCopyTextString().
◆ xsltApplyFallbacks()
|
static |
xsltApplyFallbacks: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the node generating the error
Process possible xsl:fallback nodes present under @inst
Returns the number of xsl:fallback element found and processed
Definition at line 1803 of file transform.c.
1804 {
1805
1808
1811 return(0);
1812
1817#ifdef WITH_XSLT_DEBUG_PARSING
1819 "applying xsl:fallback\n");
1820#endif
1821 ret++;
1823 NULL);
1824 }
1826 }
1828}
static void xsltApplySequenceConstructor(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr list, xsltTemplatePtr templ)
Definition: transform.c:2278
Definition: dlist.c:348
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
Referenced by xsltApplySequenceConstructor().
◆ xsltApplyImports()
| void xsltApplyImports | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | contextNode, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr comp | ATTRIBUTE_UNUSED | ||
| ) |
xsltApplyImports: @ctxt: an XSLT transformation context @contextNode: the current node in the source tree. @inst: the element node of the XSLT 'apply-imports' instruction @comp: the compiled instruction
Process the XSLT apply-imports element.
Definition at line 4610 of file transform.c.
4613{
4614 xsltTemplatePtr templ;
4615
4617 return;
4618
4621 "Internal error in xsltApplyImports(): "
4622 "The XSLT 'apply-imports' instruction was not compiled.\n");
4623 return;
4624 }
4625 /*
4626 * NOTE that ctxt->currentTemplateRule and ctxt->templ is not the
4627 * same; the former is the "Current Template Rule" as defined by the
4628 * XSLT spec, the latter is simply the template struct being
4629 * currently processed.
4630 */
4632 /*
4633 * SPEC XSLT 2.0:
4634 * "[ERR XTDE0560] It is a non-recoverable dynamic error if
4635 * xsl:apply-imports or xsl:next-match is evaluated when the
4636 * current template rule is null."
4637 */
4639 "It is an error to call 'apply-imports' "
4640 "when there's no current template rule.\n");
4641 return;
4642 }
4643 /*
4644 * TODO: Check if this is correct.
4645 */
4646 templ = xsltGetTemplate(ctxt, contextNode,
4648
4651 /*
4652 * Set the current template rule.
4653 */
4654 ctxt->currentTemplateRule = templ;
4655 /*
4656 * URGENT TODO: Need xsl:with-param be handled somehow here?
4657 */
4659 templ, NULL);
4660
4661 ctxt->currentTemplateRule = oldCurTemplRule;
4662 }
4663 else {
4664 /* Use built-in templates. */
4666 }
4667}
xsltTemplatePtr xsltGetTemplate(xsltTransformContextPtr ctxt, xmlNodePtr node, xsltStylesheetPtr style)
Definition: pattern.c:2259
static void xsltApplyXSLTTemplate(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr list, xsltTemplatePtr templ, xsltStackElemPtr withParams)
Definition: transform.c:3026
static void xsltDefaultProcessOneNode(xsltTransformContextPtr ctxt, xmlNodePtr node, xsltStackElemPtr params)
Definition: transform.c:1859
xsltTemplatePtr currentTemplateRule
Definition: xsltInternals.h:1774
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltApplyOneTemplate()
| void xsltApplyOneTemplate | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | contextNode, | ||
| xmlNodePtr | list, | ||
| xsltTemplatePtr templ | ATTRIBUTE_UNUSED, | ||
| xsltStackElemPtr | params | ||
| ) |
xsltApplyOneTemplate: @ctxt: a XSLT process context @contextNode: the node in the source tree. @list: the nodes of a sequence constructor @templ: not used @params: a set of parameters (xsl:param) or NULL
Processes a sequence constructor on the current node in the source tree.
@params are the already computed variable stack items; this function pushes them on the variable stack, and pops them before exiting; it's left to the caller to free or reuse @params afterwards. The initial states of the variable stack will always be restored before this function exits. NOTE that this does not initiate a new distinct variable scope; i.e. variables already on the stack are visible to the process. The caller's side needs to start a new variable scope if needed (e.g. in exsl:function).
@templ is obsolete and not used anymore (e.g. <exslt:function> does not provide a @templ); a non-NULL @templ might raise an error in the future.
BIG NOTE: This function is not intended to process the content of an xsl:template; it does not expect xsl:param instructions in @list and will report errors if found.
Called by:
- xsltEvalVariable() (variables.c)
- exsltFuncFunctionFunction() (libexsl/functions.c)
Definition at line 3273 of file transform.c.
3278{
3280 return;
3281 CHECK_STOPPED;
3282
3284 /*
3285 * This code should be obsolete - was previously used
3286 * by libexslt/functions.c, but due to bug 381319 the
3287 * logic there was changed.
3288 */
3290
3291 /*
3292 * Push the given xsl:param(s) onto the variable stack.
3293 */
3297 }
3299 /*
3300 * Pop the given xsl:param(s) from the stack but don't free them.
3301 */
3302 xsltLocalVariablePop(ctxt, oldVarsNr, -2);
3303 } else
3305}
void xsltLocalVariablePop(xsltTransformContextPtr ctxt, int limitNr, int level)
Definition: transform.c:150
int xsltLocalVariablePush(xsltTransformContextPtr ctxt, xsltStackElemPtr variable, int level)
Definition: transform.c:2188
Referenced by xsltEvalGlobalVariable(), xsltEvalTemplateString(), and xsltEvalVariable().
◆ xsltApplySequenceConstructor()
|
static |
xsltApplySequenceConstructor: @ctxt: a XSLT process context @contextNode: the "current node" in the source tree @list: the nodes of a sequence constructor; (plus leading xsl:param elements) @templ: the compiled xsl:template (optional)
Processes a sequence constructor.
NOTE: ctxt->currentTemplateRule was introduced to reflect the semantics of "current template rule". I.e. the field ctxt->templ is not intended to reflect this, thus always pushed onto the template stack.
Definition at line 2278 of file transform.c.
2281{
2282 xmlNodePtr oldInsert, oldInst, oldCurInst, oldContextNode;
2285 xmlDocPtr oldLocalFragmentTop;
2286
2287#ifdef XSLT_REFACTORED
2289#endif
2290
2291#ifdef WITH_DEBUGGER
2292 int addCallResult = 0;
2294#endif
2295
2297 return;
2298
2299#ifdef WITH_DEBUGGER
2301 debuggedNode =
2302 xsltDebuggerStartSequenceConstructor(ctxt, contextNode,
2303 list, templ, &addCallResult);
2305 return;
2306 }
2307#endif
2308
2310 return;
2311 CHECK_STOPPED;
2312
2313 /*
2314 * Check for infinite recursion: stop if the maximum of nested templates
2315 * is excceeded. Adjust xsltMaxDepth if you need more.
2316 */
2319 "xsltApplySequenceConstructor: A potential infinite template "
2320 "recursion was detected.\n"
2321 "You can adjust xsltMaxDepth (--maxdepth) in order to "
2322 "raise the maximum number of nested template calls and "
2323 "variables/params (currently set to %d).\n",
2324 ctxt->maxTemplateDepth);
2327 return;
2328 }
2329 ctxt->depth++;
2330
2331 oldLocalFragmentTop = ctxt->localRVT;
2333 oldInst = oldCurInst = ctxt->inst;
2334 oldContextNode = ctxt->node;
2335 /*
2336 * Save current number of variables on the stack; new vars are popped when
2337 * exiting.
2338 */
2339 oldVarsNr = ctxt->varsNr;
2340 /*
2341 * Process the sequence constructor.
2342 */
2348 "xsltApplySequenceConstructor: "
2349 "Operation limit exceeded\n");
2352 }
2353 ctxt->opCount += 1;
2354 }
2355
2357
2358#ifdef WITH_DEBUGGER
2362 break;
2363
2364 }
2365#endif
2366 /*
2367 * Test; we must have a valid insertion point.
2368 */
2370
2371#ifdef WITH_XSLT_DEBUG_PROCESS
2373 "xsltApplySequenceConstructor: insert == NULL !\n"));
2374#endif
2376 }
2377
2378#ifdef WITH_DEBUGGER
2381#endif
2382
2383#ifdef XSLT_REFACTORED
2386 /*
2387 * We expect a compiled representation on:
2388 * 1) XSLT instructions of this XSLT version (1.0)
2389 * (with a few exceptions)
2390 * 2) Literal result elements
2391 * 3) Extension instructions
2392 * 4) XSLT instructions of future XSLT versions
2393 * (forwards-compatible mode).
2394 */
2396 /*
2397 * Handle the rare cases where we don't expect a compiled
2398 * representation on an XSLT element.
2399 */
2402 goto skip_children;
2403 }
2404 /*
2405 * Something really went wrong:
2406 */
2408 "Internal error in xsltApplySequenceConstructor(): "
2409 "The element '%s' in the stylesheet has no compiled "
2410 "representation.\n",
2411 cur->name);
2412 goto skip_children;
2413 }
2414
2416 xsltStyleItemLRElementInfoPtr lrInfo =
2417 (xsltStyleItemLRElementInfoPtr) info;
2418 /*
2419 * Literal result elements
2420 * --------------------------------------------------------
2421 */
2422#ifdef WITH_XSLT_DEBUG_PROCESS
2425 "xsltApplySequenceConstructor: copy literal result "
2427#endif
2428 /*
2429 * Copy the raw element-node.
2430 * OLD: if ((copy = xsltShallowCopyElem(ctxt, cur, insert))
2431 * == NULL)
2432 * goto error;
2433 */
2437 "Internal error in xsltApplySequenceConstructor(): "
2438 "Failed to copy literal result element '%s'.\n",
2439 cur->name);
2441 } else {
2442 /*
2443 * Add the element-node to the result tree.
2444 */
2447 /*
2448 * Create effective namespaces declarations.
2449 * OLD: xsltCopyNamespaceList(ctxt, copy, cur->nsDef);
2450 */
2452 xsltEffectiveNsPtr effNs = lrInfo->effectiveNs;
2454
2456 /*
2457 * Avoid generating redundant namespace
2458 * declarations; thus lookup if there is already
2459 * such a ns-decl in the result.
2460 */
2464 {
2465 effNs = effNs->next;
2466 continue;
2467 }
2471 "Internal error in "
2472 "xsltApplySequenceConstructor(): "
2473 "Failed to copy a namespace "
2474 "declaration.\n");
2476 }
2477
2480 else
2482 lastns = ns;
2483
2484 effNs = effNs->next;
2485 }
2486
2487 }
2488 /*
2489 * NOTE that we don't need to apply ns-alising: this was
2490 * already done at compile-time.
2491 */
2493 /*
2494 * If there's no such ns-decl in the result tree,
2495 * then xsltGetSpecialNamespace() will
2496 * create a ns-decl on the copied node.
2497 */
2500 } else {
2501 /*
2502 * Undeclare the default namespace if needed.
2503 * This can be skipped, if the result element has
2504 * no ns-decls, in which case the result element
2505 * obviously does not declare a default namespace;
2506 * AND there's either no parent, or the parent
2507 * element is in no namespace; this means there's no
2508 * default namespace is scope to care about.
2509 *
2510 * REVISIT: This might result in massive
2511 * generation of ns-decls if nodes in a default
2512 * namespaces are mixed with nodes in no namespace.
2513 *
2514 */
2519 {
2522 }
2523 }
2524 }
2525 /*
2526 * SPEC XSLT 2.0 "Each attribute of the literal result
2527 * element, other than an attribute in the XSLT namespace,
2528 * is processed to produce an attribute for the element in
2529 * the result tree."
2530 * NOTE: See bug #341325.
2531 */
2534 }
2536 /*
2537 * XSLT instructions
2538 * --------------------------------------------------------
2539 */
2541 /*
2542 * We hit an unknown XSLT element.
2543 * Try to apply one of the fallback cases.
2544 */
2548 "The is no fallback behaviour defined for "
2549 "the unknown XSLT element '%s'.\n",
2550 cur->name);
2551 }
2552 ctxt->insert = oldInsert;
2554 /*
2555 * Execute the XSLT instruction.
2556 */
2558
2561
2562 /*
2563 * Cleanup temporary tree fragments.
2564 */
2566 xsltReleaseLocalRVTs(ctxt, oldLocalFragmentTop);
2567
2568 ctxt->insert = oldInsert;
2571
2573
2575 /*
2576 * TODO: Using a @tmpvar is an annoying workaround, but
2577 * the current mechanisms do not provide any other way
2578 * of knowing if the var was really pushed onto the
2579 * stack.
2580 */
2582 }
2584 /*
2585 * TODO: Won't be hit, since we don't compile xsl:message.
2586 */
2588 } else {
2591 }
2592 goto skip_children;
2593
2594 } else {
2596 /*
2597 * Extension intructions (elements)
2598 * --------------------------------------------------------
2599 */
2601 /*
2602 * The xsltExtMarker was set during the compilation
2603 * of extension instructions if there was no registered
2604 * handler for this specific extension function at
2605 * compile-time.
2606 * Libxslt will now lookup if a handler is
2607 * registered in the context of this transformation.
2608 */
2610 cur->ns->href);
2611 } else
2613
2615 /*
2616 * No handler available.
2617 * Try to execute fallback behaviour via xsl:fallback.
2618 */
2619#ifdef WITH_XSLT_DEBUG_PROCESS
2622 "xsltApplySequenceConstructor: unknown extension %s\n",
2623 cur->name));
2624#endif
2628 "Unknown extension instruction '{%s}%s'.\n",
2630 }
2631 ctxt->insert = oldInsert;
2632 } else {
2633 /*
2634 * Execute the handler-callback.
2635 */
2636#ifdef WITH_XSLT_DEBUG_PROCESS
2638 "xsltApplySequenceConstructor: extension construct %s\n",
2639 cur->name));
2640#endif
2641 /*
2642 * Disable the xsltCopyTextString optimization for
2643 * extension elements. Extensions could append text using
2644 * xmlAddChild which will free the buffer pointed to by
2645 * 'lasttext'. This buffer could later be reallocated with
2646 * a different size than recorded in 'lasttsize'. See bug
2647 * #777432.
2648 */
2651 }
2652
2654
2656
2657 /*
2658 * Cleanup temporary tree fragments.
2659 */
2661 xsltReleaseLocalRVTs(ctxt, oldLocalFragmentTop);
2662
2663 ctxt->insert = oldInsert;
2664 }
2665 goto skip_children;
2666 }
2667
2669 /*
2670 * Text
2671 * ------------------------------------------------------------
2672 */
2673#ifdef WITH_XSLT_DEBUG_PROCESS
2677 "xsltApplySequenceConstructor: copy unescaped text '%s'\n",
2678 cur->content));
2679 } else {
2682 "xsltApplySequenceConstructor: copy text '%s'\n",
2683 cur->content));
2684 }
2685#endif
2688 }
2689
2690#else /* XSLT_REFACTORED */
2691
2693 /*
2694 * This is an XSLT node
2695 */
2697
2701 } else {
2702 /*
2703 * That's an error try to apply one of the fallback cases
2704 */
2708 "xsltApplySequenceConstructor: %s was not compiled\n",
2709 cur->name);
2710 }
2711 ctxt->insert = oldInsert;
2712 }
2713 goto skip_children;
2714 }
2715
2717 oldCurInst = ctxt->inst;
2720
2722
2723 /*
2724 * Cleanup temporary tree fragments.
2725 */
2727 xsltReleaseLocalRVTs(ctxt, oldLocalFragmentTop);
2728
2729 ctxt->insert = oldInsert;
2730 ctxt->inst = oldCurInst;
2731 goto skip_children;
2732 }
2733
2736
2737 oldCurInst = ctxt->inst;
2739
2741
2742 ctxt->inst = oldCurInst;
2743
2745 /*
2746 * TODO: Using a @tmpvar is an annoying workaround, but
2747 * the current mechanisms do not provide any other way
2748 * of knowing if the var was really pushed onto the
2749 * stack.
2750 */
2752 }
2755 } else {
2758 }
2759 goto skip_children;
2762
2763 /*
2764 * This text comes from the stylesheet
2765 * For stylesheets, the set of whitespace-preserving
2766 * element names consists of just xsl:text.
2767 */
2768#ifdef WITH_XSLT_DEBUG_PROCESS
2771 "xsltApplySequenceConstructor: copy CDATA text %s\n",
2772 cur->content));
2775 "xsltApplySequenceConstructor: copy unescaped text %s\n",
2776 cur->content));
2777 } else {
2779 "xsltApplySequenceConstructor: copy text %s\n",
2780 cur->content));
2781 }
2782#endif
2787 xsltTransformFunction function;
2788
2789 oldCurInst = ctxt->inst;
2791 /*
2792 * Flagged as an extension element
2793 */
2796 cur->ns->href);
2797 else
2799
2802 int found = 0;
2803
2804#ifdef WITH_XSLT_DEBUG_PROCESS
2806 "xsltApplySequenceConstructor: unknown extension %s\n",
2807 cur->name));
2808#endif
2809 /*
2810 * Search if there are fallbacks
2811 */
2817 {
2818 found = 1;
2819 xsltApplySequenceConstructor(ctxt, contextNode,
2821 }
2823 }
2824 ctxt->insert = oldInsert;
2825
2826 if (!found) {
2828 "xsltApplySequenceConstructor: failed to find extension %s\n",
2829 cur->name);
2830 }
2831 } else {
2832#ifdef WITH_XSLT_DEBUG_PROCESS
2834 "xsltApplySequenceConstructor: extension construct %s\n",
2835 cur->name));
2836#endif
2837
2838 /*
2839 * Disable the xsltCopyTextString optimization for
2840 * extension elements. Extensions could append text using
2841 * xmlAddChild which will free the buffer pointed to by
2842 * 'lasttext'. This buffer could later be reallocated with
2843 * a different size than recorded in 'lasttsize'. See bug
2844 * #777432.
2845 */
2848 }
2849
2851
2853 /*
2854 * Cleanup temporary tree fragments.
2855 */
2857 xsltReleaseLocalRVTs(ctxt, oldLocalFragmentTop);
2858
2859 ctxt->insert = oldInsert;
2860
2861 }
2862 ctxt->inst = oldCurInst;
2863 goto skip_children;
2865#ifdef WITH_XSLT_DEBUG_PROCESS
2867 "xsltApplySequenceConstructor: copy node %s\n",
2868 cur->name));
2869#endif
2870 oldCurInst = ctxt->inst;
2872
2875 /*
2876 * Add extra namespaces inherited from the current template
2877 * if we are in the first level children and this is a
2878 * "real" template.
2879 */
2884
2889
2890 /* Note that the XSLT namespace was already excluded
2891 * in xsltGetInheritedNsList().
2892 */
2893#if 0
2895 continue;
2896#endif
2903 break;
2904
2906 }
2908 continue;
2910 URI = ns->href;
2911 /*
2912 * TODO: The following will still be buggy for the
2913 * non-refactored code.
2914 */
2917 {
2919 }
2920 }
2922 /*
2923 * Fix the node namespace if needed
2924 */
2926 }
2927 }
2928 /*
2929 * all the attributes are directly inherited
2930 */
2933 }
2934 ctxt->inst = oldCurInst;
2935 }
2936#endif /* else of XSLT_REFACTORED */
2937
2938 /*
2939 * Descend into content in document order.
2940 */
2944 level++;
2947 continue;
2948 }
2949 }
2950
2951skip_children:
2952 /*
2953 * If xslt:message was just processed, we might have hit a
2954 * terminate='yes'; if so, then break the loop and clean up.
2955 * TODO: Do we need to check this also before trying to descend
2956 * into the content?
2957 */
2959 break;
2962 continue;
2963 }
2964
2965 do {
2967 level--;
2968 /*
2969 * Pop variables/params (xsl:variable and xsl:param).
2970 */
2973 }
2974
2977 break;
2980 break;
2981 }
2984 break;
2985 }
2987 }
2988
2989error:
2990 /*
2991 * In case of errors: pop remaining variables.
2992 */
2994 xsltLocalVariablePop(ctxt, oldVarsNr, -1);
2995
2996 ctxt->node = oldContextNode;
2997 ctxt->inst = oldInst;
2998 ctxt->insert = oldInsert;
2999
3000 ctxt->depth--;
3001
3002#ifdef WITH_DEBUGGER
3004 xslDropCall();
3005 }
3006#endif
3007}
xsltTransformFunction xsltExtElementLookup(xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *URI)
Definition: extensions.c:1668
void xsltDebug(xsltTransformContextPtr ctxt, xmlNodePtr node ATTRIBUTE_UNUSED, xmlNodePtr inst ATTRIBUTE_UNUSED, xsltElemPreCompPtr comp ATTRIBUTE_UNUSED)
Definition: extra.c:35
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
static xmlNodePtr xsltCopyText(xsltTransformContextPtr ctxt, xmlNodePtr target, xmlNodePtr cur, int interned)
Definition: transform.c:945
static xmlNodePtr xsltAddChild(xmlNodePtr parent, xmlNodePtr cur)
Definition: transform.c:751
static xmlNodePtr xsltShallowCopyElem(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr insert, int isLRE)
Definition: transform.c:1296
static void xsltReleaseLocalRVTs(xsltTransformContextPtr ctxt, xmlDocPtr base)
Definition: transform.c:2226
static int xsltApplyFallbacks(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst)
Definition: transform.c:1803
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
xmlNsPtr xsltGetSpecialNamespace(xsltTransformContextPtr ctxt, xmlNodePtr invocNode, const xmlChar *nsName, const xmlChar *nsPrefix, xmlNodePtr target)
Definition: namespaces.c:299
xmlNsPtr xsltGetNamespace(xsltTransformContextPtr ctxt, xmlNodePtr cur, xmlNsPtr ns, xmlNodePtr out)
Definition: namespaces.c:596
XMLPUBFUN void *XMLCALL xmlHashLookup(xmlHashTablePtr table, const xmlChar *name)
Definition: hash.c:461
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace)
XMLPUBFUN xmlNsPtr XMLCALL xmlNewNs(xmlNodePtr node, const xmlChar *href, const xmlChar *prefix)
XMLPUBFUN xmlNodePtr XMLCALL xmlDocCopyNode(xmlNodePtr node, xmlDocPtr doc, int recursive)
Definition: tree.h:551
Definition: tree.h:389
Definition: xsltInternals.h:474
Definition: xsltInternals.h:1423
Definition: xsltInternals.h:1362
Definition: xsltInternals.h:1479
Definition: notification.c:61
Definition: mxnamespace.c:45
xmlAttrPtr xsltAttrListTemplateProcess(xsltTransformContextPtr ctxt, xmlNodePtr target, xmlAttrPtr attrs)
Definition: templates.c:635
XSLTPUBFUN void XSLTCALL xslHandleDebugger(xmlNodePtr cur, xmlNodePtr node, xsltTemplatePtr templ, xsltTransformContextPtr ctxt)
void xsltParseStylesheetVariable(xsltTransformContextPtr ctxt, xmlNodePtr inst)
Definition: variables.c:2149
void(* xsltTransformFunction)(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
Definition: xsltInternals.h:407
void xsltMessage(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst)
Definition: xsltutils.c:408
XSLTPUBFUN void XSLTCALL xslDropCall(void)
Referenced by xsltApplyFallbacks(), xsltApplyOneTemplate(), xsltApplySequenceConstructor(), xsltApplyXSLTTemplate(), xsltChoose(), xsltCopy(), xsltDocumentElem(), xsltElement(), xsltForEach(), and xsltIf().
◆ xsltApplyStripSpaces()
| void xsltApplyStripSpaces | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node | ||
| ) |
xsltApplyStripSpaces: @ctxt: a XSLT process context @node: the root of the XML tree
Strip the unwanted ignorable spaces from the input tree
Definition at line 5609 of file transform.c.
5609 {
5611#ifdef WITH_XSLT_DEBUG_PROCESS
5612 int nb = 0;
5613#endif
5614
5615
5618 /*
5619 * Cleanup children empty nodes if asked for
5620 */
5625
5629
5635#ifdef WITH_XSLT_DEBUG_PROCESS
5636 nb++;
5637#endif
5638 }
5639 }
5640 }
5641
5642 /*
5643 * Skip to next node in document order.
5644 */
5646 /* process deep in entities */
5648 }
5654 } else {
5655 do {
5658 break;
5660 goto done;
5663 break;
5664 }
5666 }
5667 }
5668
5669done:
5670#ifdef WITH_XSLT_DEBUG_PROCESS
5672 "xsltApplyStripSpaces: removed %d ignorable blank node\n", nb));
5673#endif
5674 return;
5675}
void xsltApplyStripSpaces(xsltTransformContextPtr ctxt, xmlNodePtr node)
Definition: transform.c:5609
int xsltFindElemSpaceHandling(xsltTransformContextPtr ctxt, xmlNodePtr node)
Definition: imports.c:303
XMLPUBFUN void XMLCALL xmlUnlinkNode(xmlNodePtr cur)
Referenced by xsltApplyStripSpaces(), xsltApplyStylesheetInternal(), and xsltLoadDocument().
◆ xsltApplyStylesheet()
| xmlDocPtr xsltApplyStylesheet | ( | xsltStylesheetPtr | style, |
| xmlDocPtr | doc, | ||
| const char ** | params | ||
| ) |
xsltApplyStylesheet: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated arry of parameters names/values tuples
Apply the stylesheet to the document NOTE: This may lead to a non-wellformed output XML wise !
Returns the result document or NULL in case of error
Definition at line 6144 of file transform.c.
6146{
6148}
static xmlDocPtr xsltApplyStylesheetInternal(xsltStylesheetPtr style, xmlDocPtr doc, const char **params, const char *output, FILE *profile, xsltTransformContextPtr userCtxt)
Definition: transform.c:5729
◆ xsltApplyStylesheetInternal()
|
static |
xsltApplyStylesheetInternal: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated array of parameters names/values tuples @output: the targetted output @profile: profile FILE * output or NULL @user: user provided parameter
Apply the stylesheet to the document NOTE: This may lead to a non-wellformed output XML wise !
Returns the result document or NULL in case of error
Definition at line 5729 of file transform.c.
5732{
5741 xsltStackElemPtr variables;
5742 xsltStackElemPtr vptr;
5743
5744 xsltInitGlobals();
5745
5748
5750#ifdef WITH_XSLT_DEBUG
5752 "Stylesheet was not fully internalized !\n");
5753#endif
5754 }
5756 /*
5757 * Avoid hitting the DTD when scanning nodes
5758 * but keep it linked as doc->intSubset
5759 */
5770 }
5771
5772 /*
5773 * Check for XPath document order availability
5774 */
5779 xmlXPathOrderDocElems(doc);
5780 }
5781
5783 ctxt = userCtxt;
5784 else
5786
5789
5790 ctxt->initialContextDoc = doc;
5792
5794#ifdef WITH_PROFILER
5795 ctxt->profile = 1;
5796#else
5798 "xsltApplyStylesheetInternal: "
5799 "libxslt compiled without profiler\n");
5801#endif
5802 }
5803
5805 ctxt->outputFile = output;
5806 else
5808
5809 /*
5810 * internalize the modes if needed
5811 */
5817 }
5818
5824
5827 {
5831 res = htmlNewDoc(doctypeSystem, doctypePublic);
5832 } else {
5834 xmlDtdPtr dtd;
5835
5837 /*
5838 * Make sure no DTD node is generated in this case
5839 */
5844 xmlFreeDtd(dtd);
5845 }
5848 }
5849 } else {
5850
5851#ifdef XSLT_GENERATE_HTML_DOCTYPE
5853#endif
5854 res = htmlNewDoc(doctypeSystem, doctypePublic);
5855 }
5856 }
5861
5862#ifdef WITH_XSLT_DEBUG
5864 "reusing transformation dict for output\n");
5865#endif
5868 "xsltApplyStylesheetInternal: unsupported method xhtml, using html\n");
5870 res = htmlNewDoc(doctypeSystem, doctypePublic);
5875
5876#ifdef WITH_XSLT_DEBUG
5878 "reusing transformation dict for output\n");
5879#endif
5887
5888#ifdef WITH_XSLT_DEBUG
5890 "reusing transformation dict for output\n");
5891#endif
5892 } else {
5894 "xsltApplyStylesheetInternal: unsupported method (%s)\n",
5895 method);
5897 }
5898 } else {
5905#ifdef WITH_XSLT_DEBUG
5907 "reusing transformation dict for output\n");
5908#endif
5909 }
5913 variables = style->variables;
5914
5917
5918 ctxt->xpathCtxt->contextSize = 1;
5919 ctxt->xpathCtxt->proximityPosition = 1;
5921
5922 /*
5923 * Start the evaluation, evaluate the params, the stylesheets globals
5924 * and start by processing the top node.
5925 */
5928 /*
5929 * Evaluate global params and user-provided params.
5930 */
5935 }
5936
5937 /* need to be called before evaluating global variables */
5938 xsltCountKeys(ctxt);
5939
5940 xsltEvalGlobalVariables(ctxt);
5941
5942 /* Clean up any unused RVTs. */
5944
5947
5948 /*
5949 * Start processing the source tree -----------------------------------
5950 */
5952 /*
5953 * Remove all remaining vars from the stack.
5954 */
5955 xsltLocalVariablePop(ctxt, 0, -2);
5956 xsltShutdownCtxtExts(ctxt);
5957
5959
5960 /*
5961 * Now cleanup our variables so stylesheet can be re-used
5962 *
5963 * TODO: this is not needed anymore global variables are copied
5964 * and not evaluated directly anymore, keep this as a check
5965 */
5967 vptr = style->variables;
5969 vptr = vptr->next;
5972 style->variables = variables;
5973 }
5974 vptr = style->variables;
5978 xmlXPathFreeObject(vptr->value);
5980 vptr->computed = 0;
5981 }
5982 }
5983 vptr = vptr->next;
5984 }
5985#if 0
5986 /*
5987 * code disabled by wmb; awaiting kb's review
5988 * problem is that global variable(s) may contain xpath objects
5989 * from doc associated with RVT, so can't be freed at this point.
5990 * xsltFreeTransformContext includes a call to xsltFreeRVTs, so
5991 * I assume this shouldn't be required at this point.
5992 */
5993 /*
5994 * Free all remaining tree fragments.
5995 */
5996 xsltFreeRVTs(ctxt);
5997#endif
5998 /*
5999 * Do some post processing work depending on the generated output
6000 */
6004
6008 doctype = root->name;
6009
6010 /*
6011 * Apply the default selection of the method
6012 */
6016 xmlNodePtr tmp;
6017
6021 break;
6023 break;
6024 tmp = tmp->next;
6025 }
6028 /*
6029 * REVISIT TODO: XML_HTML_DOCUMENT_NODE is set after the
6030 * transformation on the doc, but functions like
6031 */
6035 doctypePublic,
6036 doctypeSystem);
6037#ifdef XSLT_GENERATE_HTML_DOCTYPE
6040 &doctypeSystem);
6042 res->intSubset =
6044 doctypePublic,
6045 doctypeSystem);
6046#endif
6047 }
6048 }
6049
6050 }
6056 /* Need a small "hack" here to assure DTD comes before
6057 possible comment nodes */
6063 doctypePublic,
6064 doctypeSystem);
6069 } else {
6072 }
6073 }
6074 }
6075 }
6076 xmlXPathFreeNodeSet(ctxt->nodeList);
6077
6078#ifdef WITH_PROFILER
6081 }
6082#endif
6083
6084 /*
6085 * Be pedantic.
6086 */
6090 }
6093
6097 "xsltApplyStylesheet: forbidden to save to %s\n",
6098 output);
6101 "xsltApplyStylesheet: saving to %s may not be possible\n",
6102 output);
6103 }
6104 }
6105
6106#ifdef XSLT_DEBUG_PROFILE_CACHE
6110#endif
6111
6113 xsltFreeTransformContext(ctxt);
6114
6116
6117error:
6120
6121#ifdef XSLT_DEBUG_PROFILE_CACHE
6125#endif
6126
6128 xsltFreeTransformContext(ctxt);
6130}
void xsltShutdownCtxtExts(xsltTransformContextPtr ctxt)
Definition: extensions.c:1081
struct _root root
void xsltCleanupTemplates(xsltStylesheetPtr style ATTRIBUTE_UNUSED)
Definition: pattern.c:2517
int xsltCheckWrite(xsltSecurityPrefsPtr sec, xsltTransformContextPtr ctxt, const xmlChar *URL)
Definition: security.c:335
xsltTransformContextPtr xsltNewTransformContext(xsltStylesheetPtr style, xmlDocPtr doc)
Definition: transform.c:536
void xsltProcessOneNode(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xsltStackElemPtr withParams)
Definition: transform.c:2064
void xsltFreeTransformContext(xsltTransformContextPtr ctxt)
Definition: transform.c:689
static int xsltGetHTMLIDs(const xmlChar *version, const xmlChar **publicID, const xmlChar **systemID)
Definition: transform.c:5581
int xsltNeedElemSpaceHandling(xsltTransformContextPtr ctxt)
Definition: imports.c:276
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
XMLPUBFUN const xmlChar *XMLCALL xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name)
Definition: dict.c:1115
XMLPUBFUN xmlNodePtr XMLCALL xmlDocGetRootElement(const xmlDoc *doc)
XMLPUBFUN xmlDtdPtr XMLCALL xmlCreateIntSubset(xmlDocPtr doc, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID)
XMLPUBFUN void XMLCALL xmlFreeDtd(xmlDtdPtr cur)
XMLPUBFUN void XMLCALL xmlFreeDoc(xmlDocPtr cur)
XMLPUBFUN xmlDocPtr XMLCALL xmlNewDoc(const xmlChar *version)
XMLPUBFUN xmlDtdPtr XMLCALL xmlGetIntSubset(const xmlDoc *doc)
XMLPUBFUN int XMLCALL xmlIsBlankNode(const xmlNode *node)
Definition: btrfs_drv.h:450
Definition: tree.h:406
Definition: xsltInternals.h:1672
xmlNodePtr initialContextNode
Definition: xsltInternals.h:1775
int xsltEvalGlobalVariables(xsltTransformContextPtr ctxt)
Definition: variables.c:1260
int xsltEvalUserParams(xsltTransformContextPtr ctxt, const char **params)
Definition: variables.c:1662
XMLPUBFUN int XMLCALL xmlStrcasecmp(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:275
XSLTPUBFUN void XSLTCALL xsltSaveProfiling(xsltTransformContextPtr ctxt, FILE *output)
Referenced by xsltApplyStylesheet(), xsltApplyStylesheetUser(), xsltProfileStylesheet(), and xsltRunStylesheetUser().
◆ xsltApplyStylesheetUser()
| xmlDocPtr xsltApplyStylesheetUser | ( | xsltStylesheetPtr | style, |
| xmlDocPtr | doc, | ||
| const char ** | params, | ||
| const char * | output, | ||
| FILE * | profile, | ||
| xsltTransformContextPtr | userCtxt | ||
| ) |
xsltApplyStylesheetUser: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated array of parameters names/values tuples @output: the targetted output @profile: profile FILE * output or NULL @userCtxt: user provided transform context
Apply the stylesheet to the document and allow the user to provide its own transformation context.
Returns the result document or NULL in case of error
Definition at line 6187 of file transform.c.
◆ xsltApplyTemplates()
| void xsltApplyTemplates | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltApplyTemplates: @ctxt: a XSLT transformation context @node: the 'current node' in the source tree @inst: the element node of an XSLT 'apply-templates' instruction @castedComp: the compiled instruction
Processes the XSLT 'apply-templates' instruction on the current node.
Definition at line 4782 of file transform.c.
4784{
4785#ifdef XSLT_REFACTORED
4786 xsltStyleItemApplyTemplatesPtr comp =
4787 (xsltStyleItemApplyTemplatesPtr) castedComp;
4788#else
4790#endif
4795 int oldXPProximityPosition, oldXPContextSize;
4797 xmlDocPtr oldXPDoc;
4798 xsltDocumentPtr oldDocInfo;
4799 xmlXPathContextPtr xpctxt;
4800
4803 "xsl:apply-templates : compilation failed\n");
4804 return;
4805 }
4807 return;
4808
4809#ifdef WITH_XSLT_DEBUG_PROCESS
4813#endif
4814
4815 xpctxt = ctxt->xpathCtxt;
4816 /*
4817 * Save context states.
4818 */
4819 oldContextNode = ctxt->node;
4820 oldMode = ctxt->mode;
4821 oldModeURI = ctxt->modeURI;
4822 oldDocInfo = ctxt->document;
4823 oldList = ctxt->nodeList;
4824
4825 /*
4826 * The xpath context size and proximity position, as
4827 * well as the xpath and context documents, may be changed
4828 * so we save their initial state and will restore on exit
4829 */
4830 oldXPContextSize = xpctxt->contextSize;
4831 oldXPProximityPosition = xpctxt->proximityPosition;
4832 oldXPDoc = xpctxt->doc;
4833
4834 /*
4835 * Set up contexts.
4836 */
4837 ctxt->mode = comp->mode;
4838 ctxt->modeURI = comp->modeURI;
4839
4842
4845 "xsl:apply-templates : compilation failed\n");
4847 }
4848#ifdef WITH_XSLT_DEBUG_PROCESS
4850 "xsltApplyTemplates: select %s\n", comp->select));
4851#endif
4852
4854
4859 } else {
4861 "The 'select' expression did not evaluate to a "
4862 "node set.\n");
4864 xmlXPathFreeObject(res);
4866 }
4867 xmlXPathFreeObject(res);
4868 /*
4869 * Note: An xsl:apply-templates with a 'select' attribute,
4870 * can change the current source doc.
4871 */
4872 } else {
4874 "Failed to evaluate the 'select' expression.\n");
4877 }
4879#ifdef WITH_XSLT_DEBUG_PROCESS
4881 "xsltApplyTemplates: select didn't evaluate to a node list\n"));
4882#endif
4884 }
4885 /*
4886 *
4887 * NOTE: Previously a document info (xsltDocument) was
4888 * created and attached to the Result Tree Fragment.
4889 * But such a document info is created on demand in
4890 * xsltKeyFunction() (functions.c), so we need to create
4891 * it here beforehand.
4892 * In order to take care of potential keys we need to
4893 * do some extra work for the case when a Result Tree Fragment
4894 * is converted into a nodeset (e.g. exslt:node-set()) :
4895 * We attach a "pseudo-doc" (xsltDocument) to _private.
4896 * This xsltDocument, together with the keyset, will be freed
4897 * when the Result Tree Fragment is freed.
4898 *
4899 */
4900#if 0
4902 (list->nodeNr != 0) &&
4905 {
4906 /*
4907 * NOTE that it's also OK if @effectiveDocInfo will be
4908 * set to NULL.
4909 */
4910 isRTF = 1;
4911 effectiveDocInfo = list->nodeTab[0]->doc->_private;
4912 }
4913#endif
4914 } else {
4915 /*
4916 * Build an XPath node set with the children
4917 */
4923 else
4929 }
4930 }
4931
4932#ifdef WITH_XSLT_DEBUG_PROCESS
4936#endif
4937
4940
4941 /*
4942 * Set the context's node set and size; this is also needed for
4943 * for xsltDoSortFunction().
4944 */
4946 /*
4947 * Process xsl:with-param and xsl:sort instructions.
4948 * (The code became so verbose just to avoid the
4949 * xmlNodePtr sorts[XSLT_MAX_SORT] if there's no xsl:sort)
4950 * BUG TODO: We are not using namespaced potentially defined on the
4951 * xsl:sort or xsl:with-param elements; XPath expression might fail.
4952 */
4955
4958
4959#ifdef WITH_DEBUGGER
4962#endif
4964 break;
4967 continue;
4968 }
4970 break;
4974 param->next = withParams;
4975 withParams = param;
4976 }
4977 }
4979 xsltTemplatePtr oldCurTempRule =
4980 ctxt->currentTemplateRule;
4981 int nbsorts = 0;
4983
4984 sorts[nbsorts++] = cur;
4986
4988
4989#ifdef WITH_DEBUGGER
4992#endif
4994 break;
4995
4998 continue;
4999 }
5000
5002 break;
5006 param->next = withParams;
5007 withParams = param;
5008 }
5009 }
5013 "The number (%d) of xsl:sort instructions exceeds the "
5014 "maximum allowed by this processor's settings.\n",
5015 nbsorts);
5017 break;
5018 } else {
5019 sorts[nbsorts++] = cur;
5020 }
5021 }
5023 }
5024 /*
5025 * The "current template rule" is cleared for xsl:sort.
5026 */
5028 /*
5029 * Sort.
5030 */
5031 xsltDoSortFunction(ctxt, sorts, nbsorts);
5032 ctxt->currentTemplateRule = oldCurTempRule;
5033 break;
5034 }
5036 }
5037 }
5038 xpctxt->contextSize = list->nodeNr;
5039 /*
5040 * Apply templates for all selected source nodes.
5041 */
5044 /*
5045 * The node becomes the "current node".
5046 */
5048 /*
5049 * An xsl:apply-templates can change the current context doc.
5050 * OPTIMIZE TODO: Get rid of the need to set the context doc.
5051 */
5053 xpctxt->doc = cur->doc;
5054
5055 xpctxt->proximityPosition = i + 1;
5056 /*
5057 * Find and apply a template for this node.
5058 */
5060 }
5061
5062exit:
5063error:
5064 /*
5065 * Free the parameter list.
5066 */
5068 xsltFreeStackElemList(withParams);
5070 xmlXPathFreeNodeSet(list);
5071 /*
5072 * Restore context states.
5073 */
5074 xpctxt->doc = oldXPDoc;
5075 xpctxt->contextSize = oldXPContextSize;
5076 xpctxt->proximityPosition = oldXPProximityPosition;
5077
5078 ctxt->document = oldDocInfo;
5079 ctxt->nodeList = oldList;
5080 ctxt->node = oldContextNode;
5081 ctxt->mode = oldMode;
5082 ctxt->modeURI = oldModeURI;
5083}
static xmlXPathObjectPtr xsltPreCompEval(xsltTransformContextPtr ctxt, xmlNodePtr node, xsltStylePreCompPtr comp)
Definition: transform.c:321
Definition: xsltInternals.h:332
xsltStackElemPtr xsltParseStylesheetCallerParam(xsltTransformContextPtr ctxt, xmlNodePtr inst)
Definition: variables.c:1962
void xsltDoSortFunction(xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)
Definition: xsltutils.c:1369
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltApplyXSLTTemplate()
|
static |
Definition at line 3026 of file transform.c.
3031{
3032 int oldVarsBase = 0;
3035 xmlDocPtr oldUserFragmentTop;
3036#ifdef WITH_PROFILER
3038#endif
3039
3040#ifdef XSLT_REFACTORED
3041 xsltStyleItemParamPtr iparam;
3042#else
3043 xsltStylePreCompPtr iparam;
3044#endif
3045
3046#ifdef WITH_DEBUGGER
3047 int addCallResult = 0;
3048#endif
3049
3051 return;
3054 "xsltApplyXSLTTemplate: Bad arguments; @templ is mandatory.\n");
3055 return;
3056 }
3057
3058#ifdef WITH_DEBUGGER
3060 if (xsltDebuggerStartSequenceConstructor(ctxt, contextNode,
3062 return;
3063 }
3064#endif
3065
3067 return;
3068 CHECK_STOPPED;
3069
3071 {
3073 "xsltApplyXSLTTemplate: A potential infinite template recursion "
3074 "was detected.\n"
3075 "You can adjust maxTemplateVars (--maxvars) in order to "
3076 "raise the maximum number of variables/params (currently set to %d).\n",
3077 ctxt->maxTemplateVars);
3080 return;
3081 }
3082
3083 oldUserFragmentTop = ctxt->tmpRVT;
3085
3086 /*
3087 * Initiate a distinct scope of local params/variables.
3088 */
3089 oldVarsBase = ctxt->varsBase;
3091
3092 ctxt->node = contextNode;
3093
3094#ifdef WITH_PROFILER
3096 templ->nbCalls++;
3098 profPush(ctxt, 0);
3099 profCallgraphAdd(templ, ctxt->templ);
3100 }
3101#endif
3102
3103 /*
3104 * Push the xsl:template declaration onto the stack.
3105 */
3106 templPush(ctxt, templ);
3107
3108#ifdef WITH_XSLT_DEBUG_PROCESS
3112#endif
3113 /*
3114 * Process xsl:param instructions and skip those elements for
3115 * further processing.
3116 */
3118 do {
3121 continue;
3122 }
3128 {
3129 break;
3130 }
3131
3133
3134#ifdef XSLT_REFACTORED
3135 iparam = (xsltStyleItemParamPtr) cur->psvi;
3136#else
3138#endif
3139
3140 /*
3141 * Substitute xsl:param for a given xsl:with-param.
3142 * Since the XPath expression will reference the params/vars
3143 * by index, we need to slot the xsl:with-params in the
3144 * order of encountered xsl:params to keep the sequence of
3145 * params/variables in the stack exactly as it was at
3146 * compile time,
3147 */
3148 tmpParam = NULL;
3149 if (withParams) {
3150 tmpParam = withParams;
3151 do {
3153 (tmpParam->nameURI == (iparam->ns)))
3154 {
3155 /*
3156 * Push the caller-parameter.
3157 */
3158 xsltLocalVariablePush(ctxt, tmpParam, -1);
3159 break;
3160 }
3161 tmpParam = tmpParam->next;
3163 }
3164 /*
3165 * Push the xsl:param.
3166 */
3168 /*
3169 * Note that we must assume that the added parameter
3170 * has a @depth of 0.
3171 */
3173 }
3176 /*
3177 * Process the sequence constructor.
3178 */
3180
3181 /*
3182 * Remove remaining xsl:param and xsl:with-param items from
3183 * the stack. Don't free xsl:with-param items.
3184 */
3186 xsltTemplateParamsCleanup(ctxt);
3187 ctxt->varsBase = oldVarsBase;
3188
3189 /*
3190 * Release user-created fragments stored in the scope
3191 * of xsl:template. Note that this mechanism is deprecated:
3192 * user code should now use xsltRegisterLocalRVT() instead
3193 * of the obsolete xsltRegisterTmpRVT().
3194 */
3197
3199 tmp = curdoc;
3201 xsltReleaseRVT(ctxt, tmp);
3202 }
3203 }
3204 ctxt->tmpRVT = oldUserFragmentTop;
3205
3206 /*
3207 * Pop the xsl:template declaration from the stack.
3208 */
3209 templPop(ctxt);
3210
3211#ifdef WITH_PROFILER
3214
3216 child = profPop(ctxt);
3219 if (spent <= 0) {
3220 /*
3221 * Not possible unless the original calibration failed
3222 * we can try to correct it on the fly.
3223 */
3224 xsltCalibrateAdjust(spent);
3225 spent = 0;
3226 }
3227
3228 templ->time += spent;
3231 }
3232#endif
3233
3234#ifdef WITH_DEBUGGER
3236 xslDropCall();
3237 }
3238#endif
3239}
static void xsltTemplateParamsCleanup(xsltTransformContextPtr ctxt)
Definition: transform.c:180
static int templPush(xsltTransformContextPtr ctxt, xsltTemplatePtr value)
Definition: transform.c:85
void xsltParseStylesheetParam(xsltTransformContextPtr ctxt, xmlNodePtr cur)
Definition: variables.c:2191
void xsltReleaseRVT(xsltTransformContextPtr ctxt, xmlDocPtr RVT)
Definition: variables.c:328
XSLTPUBFUN void XSLTCALL xsltCalibrateAdjust(long delta)
XSLTPUBFUN long XSLTCALL xsltTimestamp(void)
Referenced by xsltApplyImports(), xsltCallTemplate(), xsltDefaultProcessOneNode(), and xsltProcessOneNode().
◆ xsltCallTemplate()
| void xsltCallTemplate | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltCallTemplate: @ctxt: a XSLT transformation context @node: the "current node" in the source tree @inst: the XSLT 'call-template' instruction @castedComp: the compiled information of the instruction
Processes the XSLT call-template instruction on the source node.
Definition at line 4679 of file transform.c.
4681{
4682#ifdef XSLT_REFACTORED
4683 xsltStyleItemCallTemplatePtr comp =
4684 (xsltStyleItemCallTemplatePtr) castedComp;
4685#else
4687#endif
4689
4691 return;
4694 "The XSLT 'call-template' instruction was not compiled.\n");
4695 return;
4696 }
4697
4698 /*
4699 * The template must have been precomputed
4700 */
4702 comp->templ = xsltFindTemplate(ctxt, comp->name, comp->ns);
4706 "The called template '{%s}%s' was not found.\n",
4707 comp->ns, comp->name);
4708 } else {
4710 "The called template '%s' was not found.\n",
4711 comp->name);
4712 }
4713 return;
4714 }
4715 }
4716
4717#ifdef WITH_XSLT_DEBUG_PROCESS
4720 "call-template: name %s\n", comp->name));
4721#endif
4722
4726
4729#ifdef WITH_DEBUGGER
4732#endif
4734 /*
4735 * TODO: The "with-param"s could be part of the "call-template"
4736 * structure. Avoid to "search" for params dynamically
4737 * in the XML tree every time.
4738 */
4743 param->next = withParams;
4744 withParams = param;
4745 }
4746 } else {
4749 }
4750 } else {
4753 }
4755 }
4756 }
4757 /*
4758 * Create a new frame using the params first
4759 */
4761 withParams);
4763 xsltFreeStackElemList(withParams);
4764
4765#ifdef WITH_XSLT_DEBUG_PROCESS
4768 "call-template returned: name %s\n", comp->name));
4769#endif
4770}
xsltTemplatePtr xsltFindTemplate(xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *nameURI)
Definition: imports.c:357
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltChoose()
| void xsltChoose | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | contextNode, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr comp | ATTRIBUTE_UNUSED | ||
| ) |
xsltChoose: @ctxt: a XSLT process context @contextNode: the current node in the source tree @inst: the xsl:choose instruction @comp: compiled information of the instruction
Processes the xsl:choose instruction on the source node.
Definition at line 5096 of file transform.c.
5098{
5100
5102 return;
5103
5104 /*
5105 * TODO: Content model checks should be done only at compilation
5106 * time.
5107 */
5111 "xsl:choose: The instruction has no content.\n");
5112 return;
5113 }
5114
5115#ifdef XSLT_REFACTORED
5116 /*
5117 * We don't check the content model during transformation.
5118 */
5119#else
5122 "xsl:choose: xsl:when expected first\n");
5123 return;
5124 }
5125#endif
5126
5127 {
5129
5130#ifdef XSLT_REFACTORED
5131 xsltStyleItemWhenPtr wcomp = NULL;
5132#else
5134#endif
5135
5136 /*
5137 * Process xsl:when ---------------------------------------------------
5138 */
5140 wcomp = cur->psvi;
5141
5143 (wcomp->comp == NULL))
5144 {
5146 "Internal error in xsltChoose(): "
5147 "The XSLT 'when' instruction was not compiled.\n");
5149 }
5150
5151
5152#ifdef WITH_DEBUGGER
5154 /*
5155 * TODO: Isn't comp->templ always NULL for xsl:choose?
5156 */
5158 }
5159#endif
5160#ifdef WITH_XSLT_DEBUG_PROCESS
5162 "xsltChoose: test %s\n", wcomp->test));
5163#endif
5164
5165#ifdef XSLT_FAST_IF
5167
5171 }
5172 testRes = (res == 1) ? 1 : 0;
5173
5174#else /* XSLT_FAST_IF */
5175
5177
5182 testRes = res->boolval;
5183 else {
5184#ifdef WITH_XSLT_DEBUG_PROCESS
5186 "xsltChoose: test didn't evaluate to a boolean\n"));
5187#endif
5189 }
5190 xmlXPathFreeObject(res);
5192 } else {
5195 }
5196
5197#endif /* else of XSLT_FAST_IF */
5198
5199#ifdef WITH_XSLT_DEBUG_PROCESS
5201 "xsltChoose: test evaluate to %d\n", testRes));
5202#endif
5203 if (testRes)
5204 goto test_is_true;
5205
5207 }
5208
5209 /*
5210 * Process xsl:otherwise ----------------------------------------------
5211 */
5213
5214#ifdef WITH_DEBUGGER
5217#endif
5218
5219#ifdef WITH_XSLT_DEBUG_PROCESS
5221 "evaluating xsl:otherwise\n"));
5222#endif
5223 goto test_is_true;
5224 }
5226
5227test_is_true:
5228
5229 goto process_sequence;
5230 }
5231
5232process_sequence:
5233
5234 /*
5235 * Instantiate the sequence constructor.
5236 */
5238 NULL);
5239
5240exit:
5241error:
5242 return;
5243}
static int xsltPreCompEvalToBoolean(xsltTransformContextPtr ctxt, xmlNodePtr node, xsltStylePreCompPtr comp)
Definition: transform.c:370
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltComment()
| void xsltComment | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr comp | ATTRIBUTE_UNUSED | ||
| ) |
xsltComment: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt comment node @comp: precomputed information
Process the xslt comment node on the source node
Definition at line 4225 of file transform.c.
4226 {
4228 xmlNodePtr commentNode;
4230
4232 /* TODO: use or generate the compiled form */
4238 "xsl:comment : '--' or ending '-' not allowed in comment\n");
4239 /* fall through to try to catch further errors */
4240 }
4241 }
4242#ifdef WITH_XSLT_DEBUG_PROCESS
4245 "xsltComment: empty\n"));
4246 } else {
4249 }
4250#endif
4251
4254
4257}
XMLPUBFUN xmlNodePtr XMLCALL xmlNewComment(const xmlChar *content)
xmlChar * xsltEvalTemplateString(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst)
Definition: templates.c:189
XMLPUBFUN const xmlChar *XMLCALL xmlStrstr(const xmlChar *str, const xmlChar *val)
Definition: xmlstring.c:345
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltCopy()
| void xsltCopy | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltCopy: @ctxt: an XSLT process context @node: the node in the source tree @inst: the element node of the XSLT-copy instruction @castedComp: computed information of the XSLT-copy instruction
Execute the XSLT-copy instruction on the source node.
Definition at line 3861 of file transform.c.
3863{
3864#ifdef XSLT_REFACTORED
3865 xsltStyleItemCopyPtr comp = (xsltStyleItemCopyPtr) castedComp;
3866#else
3868#endif
3870
3871 oldInsert = ctxt->insert;
3876 /*
3877 * This text comes from the stylesheet
3878 * For stylesheets, the set of whitespace-preserving
3879 * element names consists of just xsl:text.
3880 */
3881#ifdef WITH_XSLT_DEBUG_PROCESS
3885 } else {
3888 }
3889#endif
3891 break;
3894 break;
3896 /*
3897 * REVISIT NOTE: The "fake" is a doc-node, not an element node.
3898 * REMOVED:
3899 * if (xmlStrEqual(node->name, BAD_CAST " fake node libxslt"))
3900 * return;
3901 */
3902
3903#ifdef WITH_XSLT_DEBUG_PROCESS
3906#endif
3911 }
3912 break;
3914#ifdef WITH_XSLT_DEBUG_PROCESS
3917#endif
3918 /*
3919 * REVISIT: We could also raise an error if the parent is not
3920 * an element node.
3921 * OPTIMIZE TODO: Can we set the value/children of the
3922 * attribute without an intermediate copy of the string value?
3923 */
3925 break;
3926 }
3928#ifdef WITH_XSLT_DEBUG_PROCESS
3931#endif
3933 node->content);
3935 break;
3937#ifdef WITH_XSLT_DEBUG_PROCESS
3939 "xsltCopy: comment\n"));
3940#endif
3943 break;
3945#ifdef WITH_XSLT_DEBUG_PROCESS
3947 "xsltCopy: namespace declaration\n"));
3948#endif
3950 break;
3951 default:
3952 break;
3953
3954 }
3955 }
3956
3962 NULL);
3963 break;
3964 default:
3965 break;
3966 }
3967 ctxt->insert = oldInsert;
3968}
void xsltApplyAttributeSet(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, const xmlChar *attrSets)
Definition: attributes.c:1086
static xmlAttrPtr xsltShallowCopyAttr(xsltTransformContextPtr ctxt, xmlNodePtr invocNode, xmlNodePtr target, xmlAttrPtr attr)
Definition: transform.c:1121
static xmlNsPtr xsltShallowCopyNsNode(xsltTransformContextPtr ctxt, xmlNodePtr invocNode, xmlNodePtr insert, xmlNsPtr ns)
Definition: transform.c:1481
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocPI(xmlDocPtr doc, const xmlChar *name, const xmlChar *content)
Definition: tree.h:434
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltCopyAttrListNoOverwrite()
|
static |
xsltCopyAttrListNoOverwrite: @ctxt: a XSLT process context @invocNode: responsible node in the stylesheet; used for error reports @target: the element where the new attributes will be grafted @attr: the first attribute in the list to be copied
Copies a list of attribute nodes, starting with @attr, over to the @target element node.
Called by:
Returns 0 on success and -1 on errors and internal errors.
Definition at line 1220 of file transform.c.
1223{
1227
1228 /*
1229 * Don't use xmlCopyProp() here, since it will try to
1230 * reconciliate namespaces.
1231 */
1233 /*
1234 * Find a namespace node in the tree of @target.
1235 * Avoid searching for the same ns.
1236 */
1238 origNs = attr->ns;
1240 copyNs = xsltGetSpecialNamespace(ctxt, invocNode,
1243 return(-1);
1244 } else
1245 copyNs = NULL;
1246 }
1247 /*
1248 * If attribute has a value, we need to copy it (watching out
1249 * for possible entities)
1250 */
1254 attr->children->content);
1259 } else {
1261 }
1262
1264 return(-1);
1265
1267 }
1268 return(0);
1269}
XMLPUBFUN xmlAttrPtr XMLCALL xmlNewNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name, const xmlChar *value)
XMLPUBFUN xmlChar *XMLCALL xmlNodeListGetString(xmlDocPtr doc, const xmlNode *list, int inLine)
Definition: cookie.c:202
Referenced by xsltCopyTree().
◆ xsltCopyNamespaceListInternal()
|
static |
xsltCopyNamespaceListInternal: @node: the target node @cur: the first namespace
Do a copy of a namespace list. If @node is non-NULL the new namespaces are added automatically. Called by: xsltCopyTree()
QUESTION: What is the exact difference between this function and xsltCopyNamespaceList() in "namespaces.c"? ANSWER: xsltCopyNamespaceList() tries to apply ns-aliases.
Returns: a new xmlNsPtr, or NULL in case of error.
Definition at line 1424 of file transform.c.
1424 {
1427
1430 /*
1431 * One can add namespaces only on element nodes
1432 */
1435
1436 do {
1438 break;
1439 /*
1440 * Avoid duplicating namespace declarations on the tree.
1441 */
1446 {
1448 continue;
1449 }
1452 {
1454 continue;
1455 }
1456 }
1463 }
1467}
Referenced by xsltCopyTree(), and xsltShallowCopyElem().
◆ xsltCopyOf()
| void xsltCopyOf | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltCopyOf: @ctxt: an XSLT transformation context @node: the current node in the source tree @inst: the element node of the XSLT copy-of instruction @castedComp: precomputed information of the XSLT copy-of instruction
Process the XSLT copy-of instruction.
Definition at line 4335 of file transform.c.
4336 {
4337#ifdef XSLT_REFACTORED
4338 xsltStyleItemCopyOfPtr comp = (xsltStyleItemCopyOfPtr) castedComp;
4339#else
4341#endif
4345
4347 return;
4350 "xsl:copy-of : compilation failed\n");
4351 return;
4352 }
4353
4354 /*
4355 * SPEC XSLT 1.0:
4356 * "The xsl:copy-of element can be used to insert a result tree
4357 * fragment into the result tree, without first converting it to
4358 * a string as xsl:value-of does (see [7.6.1 Generating Text with
4359 * xsl:value-of]). The required select attribute contains an
4360 * expression. When the result of evaluating the expression is a
4361 * result tree fragment, the complete fragment is copied into the
4362 * result tree. When the result is a node-set, all the nodes in the
4363 * set are copied in document order into the result tree; copying
4364 * an element node copies the attribute nodes, namespace nodes and
4365 * children of the element node as well as the element node itself;
4366 * a root node is copied by copying its children. When the result
4367 * is neither a node-set nor a result tree fragment, the result is
4368 * converted to a string and then inserted into the result tree,
4369 * as with xsl:value-of.
4370 */
4371
4372#ifdef WITH_XSLT_DEBUG_PROCESS
4374 "xsltCopyOf: select %s\n", comp->select));
4375#endif
4376
4377 /*
4378 * Evaluate the "select" expression.
4379 */
4381
4384 /*
4385 * Node-set
4386 * --------
4387 */
4388#ifdef WITH_XSLT_DEBUG_PROCESS
4390 "xsltCopyOf: result is a node set\n"));
4391#endif
4395 /*
4396 * The list is already sorted in document order by XPath.
4397 * Append everything in this order under ctxt->insert.
4398 */
4402 continue;
4405 {
4406 xsltCopyTreeList(ctxt, inst,
4409 xsltShallowCopyAttr(ctxt, inst,
4411 } else {
4413 }
4414 }
4415 }
4417 /*
4418 * Result tree fragment
4419 * --------------------
4420 * E.g. via <xsl:variable ...><foo/></xsl:variable>
4421 * Note that the root node of such trees is an xmlDocPtr in Libxslt.
4422 */
4423#ifdef WITH_XSLT_DEBUG_PROCESS
4425 "xsltCopyOf: result is a result tree fragment\n"));
4426#endif
4431 {
4432 xsltCopyTreeList(ctxt, inst,
4434 }
4435 } else {
4437 /*
4438 * Convert to a string.
4439 */
4443 "Internal error in xsltCopyOf(): "
4444 "failed to cast an XPath object to string.\n");
4446 } else {
4448 /*
4449 * Append content as text node.
4450 */
4452 }
4454
4455#ifdef WITH_XSLT_DEBUG_PROCESS
4458#endif
4459 }
4460 }
4461 } else {
4463 }
4464
4466 xmlXPathFreeObject(res);
4467}
xmlNodePtr xsltCopyTextString(xsltTransformContextPtr ctxt, xmlNodePtr target, const xmlChar *string, int noescape)
Definition: transform.c:849
static xmlNodePtr xsltCopyTreeList(xsltTransformContextPtr ctxt, xmlNodePtr invocNode, xmlNodePtr list, xmlNodePtr insert, int isLRE, int topElemVisited)
Definition: transform.c:1388
static xmlNodePtr xsltCopyTree(xsltTransformContextPtr ctxt, xmlNodePtr invocNode, xmlNodePtr node, xmlNodePtr insert, int isLRE, int topElemVisited)
Definition: transform.c:1592
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltCopyText()
|
static |
xsltCopyText: @ctxt: a XSLT process context @target: the element where the text will be attached @cur: the text or CDATA node @interned: the string is in the target doc dictionary
Copy the text content of @cur and append it to @target's children.
Returns: the text node, where the text content of @cur is copied to. NULL in case of API or internal errors.
Definition at line 945 of file transform.c.
947{
949
955
956#ifdef WITH_XSLT_DEBUG_PROCESS
959 "xsltCopyText: copy CDATA text %s\n",
960 cur->content));
963 "xsltCopyText: copy unescaped text %s\n",
964 cur->content));
965 } else {
967 "xsltCopyText: copy text %s\n",
968 cur->content));
969 }
970#endif
971
972 /*
973 * Play save and reset the merging mechanism for every new
974 * target node.
975 */
978 }
979
990 {
991 /*
992 * Process "cdata-section-elements".
993 */
994 /*
995 * OPTIMIZE TODO: xsltCopyText() is also used for attribute content.
996 */
997 /*
998 * TODO: Since this doesn't merge adjacent CDATA-section nodes,
999 * we'll get: <![CDATA[x]]><!CDATA[y]]>.
1000 * TODO: Reported in #321505.
1001 */
1004 {
1005 /*
1006 * Append to existing CDATA-section node.
1007 */
1011 } else {
1013
1021 }
1024 /* both escaped or both non-escaped text-nodes */
1027 /* non-escaped text nodes and CDATA-section nodes */
1030 {
1031 /*
1032 * we are appending to an existing text node
1033 */
1040 {
1041 /*
1042 * TODO: DO we want to use this also for "text" output?
1043 */
1049
1050 /*
1051 * Must confirm that content is in dict (bug 302821)
1052 * TODO: This check should be not needed for text coming
1053 * from the stylesheets
1054 */
1057 else {
1060 }
1061
1063 } else {
1064 /*
1065 * normal processing. keep counters to extend the text node
1066 * in xsltAddTextString if needed.
1067 */
1069
1079 }
1083 /*
1084 * MAYBE TODO: Maybe we should reset the ctxt->lasttext here
1085 * to ensure that the optimized text-merging mechanism
1086 * won't interfere with normal node-merging in any case.
1087 */
1089 }
1090 } else {
1092 "xsltCopyText: text copy failed\n");
1093 }
1094
1095exit:
1098 "Internal error in xsltCopyText(): "
1099 "Failed to copy the string.\n");
1101 }
1103}
static xmlNodePtr xsltAddTextString(xsltTransformContextPtr ctxt, xmlNodePtr target, const xmlChar *string, int len)
Definition: transform.c:777
XMLPUBFUN int XMLCALL xmlDictOwns(xmlDictPtr dict, const xmlChar *str)
Definition: dict.c:1220
XMLPUBFUN void *XMLCALL xmlHashLookup2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2)
Definition: hash.c:476
XMLPUBFUN xmlNodePtr XMLCALL xmlNewTextLen(const xmlChar *content, int len)
XMLPUBFUN xmlNodePtr XMLCALL xmlNewCDataBlock(xmlDocPtr doc, const xmlChar *content, int len)
Referenced by xsltApplySequenceConstructor(), xsltCopy(), xsltDefaultProcessOneNode(), and xsltShallowCopyElem().
◆ xsltCopyTextString()
| xmlNodePtr xsltCopyTextString | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | target, | ||
| const xmlChar * | string, | ||
| int | noescape | ||
| ) |
xsltCopyTextString: @ctxt: a XSLT process context @target: the element where the text will be attached @string: the text string @noescape: should disable-escaping be activated for this text node.
Adds @string to a newly created or an existent text node child of @target.
Returns: the text node, where the text content of @cur is copied to. NULL in case of API or internal errors.
Definition at line 849 of file transform.c.
851{
854
857
858#ifdef WITH_XSLT_DEBUG_PROCESS
860 "xsltCopyTextString: copy text %s\n",
861 string));
862#endif
863
864 /*
865 * Play safe and reset the merging mechanism for every new
866 * target node.
867 */
870 }
871
872 /* handle coalescing of text nodes here */
884 {
885 /*
886 * Process "cdata-section-elements".
887 */
890 {
892 }
894 } else if (noescape) {
895 /*
896 * Process "disable-output-escaping".
897 */
901 {
903 }
907 } else {
908 /*
909 * Default processing.
910 */
915 }
917 }
924 } else {
926 "xsltCopyTextString: text copy failed\n");
928 }
930}
Referenced by xsltCopyOf(), xsltCopyTree(), xsltNumberFormat(), and xsltValueOf().
◆ xsltCopyTree()
|
static |
xsltCopyTree: @ctxt: the XSLT transformation context @invocNode: responsible node in the stylesheet; used for error reports @node: the element node in the source tree @insert: the parent in the result tree @isLRE: indicates if @node is a Literal Result Element @topElemVisited: indicates if a top-most element was already processed
Make a copy of the full tree under the element node @node and insert it as last child of @insert
NOTE: Not to be used for Literal Result Elements.
Used by:
Returns a pointer to the new tree, or NULL in case of error
Definition at line 1592 of file transform.c.
1595{
1597
1608#ifdef LIBXML_DOCB_ENABLED
1610#endif
1611 break;
1615 }
1624
1635 }
1640 else
1643 }
1652 }
1653 /*
1654 * The node may have been coalesced into another text node.
1655 */
1659
1661 /*
1662 * Copy in-scope namespace nodes.
1663 *
1664 * REVISIT: Since we try to reuse existing in-scope ns-decls by
1665 * using xmlSearchNsByHref(), this will eventually change
1666 * the prefix of an original ns-binding; thus it might
1667 * break QNames in element/attribute content.
1668 * OPTIMIZE TODO: If we had a xmlNsPtr * on the transformation
1669 * context, plus a ns-lookup function, which writes directly
1670 * to a given list, then we wouldn't need to create/free the
1671 * nsList every time.
1672 */
1673 if ((topElemVisited == 0) &&
1677 {
1679
1680 /*
1681 * If this is a top-most element in a tree to be
1682 * copied, then we need to ensure that all in-scope
1683 * namespaces are copied over. For nodes deeper in the
1684 * tree, it is sufficient to reconcile only the ns-decls
1685 * (node->nsDef entries).
1686 */
1687
1690 curns = nsList;
1691 do {
1692 /*
1693 * Search by prefix first in order to break as less
1694 * QNames in element/attribute content as possible.
1695 */
1697 (*curns)->prefix);
1698
1701 {
1703 /*
1704 * Search by namespace name.
1705 * REVISIT TODO: Currently disabled.
1706 */
1707#if 0
1709 insert, (*curns)->href);
1710#endif
1711 }
1713 /*
1714 * Declare a new namespace on the copied element.
1715 */
1717 (*curns)->prefix);
1718 /* TODO: Handle errors */
1719 }
1721 /*
1722 * If this was the original's namespace then set
1723 * the generated counterpart on the copy.
1724 */
1726 }
1727 curns++;
1729 xmlFree(nsList);
1730 }
1732 /*
1733 * Copy over all namespace declaration attributes.
1734 */
1736 if (isLRE)
1738 else
1740 }
1741 }
1742 /*
1743 * Set the namespace.
1744 */
1747 /*
1748 * This will map copy->ns to one of the newly created
1749 * in-scope ns-decls, OR create a new ns-decl on @copy.
1750 */
1753 }
1756 {
1757 /*
1758 * "Undeclare" the default namespace on @copy with xmlns="".
1759 */
1761 }
1762 /*
1763 * Copy attribute nodes.
1764 */
1766 xsltCopyAttrListNoOverwrite(ctxt, invocNode,
1768 }
1769 if (topElemVisited == 0)
1770 topElemVisited = 1;
1771 }
1772 /*
1773 * Copy the subtree.
1774 */
1776 xsltCopyTreeList(ctxt, invocNode,
1778 }
1779 } else {
1782 }
1784}
static xmlNsPtr xsltCopyNamespaceListInternal(xmlNodePtr node, xmlNsPtr cur)
Definition: transform.c:1424
static int xsltCopyAttrListNoOverwrite(xsltTransformContextPtr ctxt, xmlNodePtr invocNode, xmlNodePtr target, xmlAttrPtr attr)
Definition: transform.c:1220
xmlNsPtr xsltCopyNamespaceList(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNsPtr cur)
Definition: namespaces.c:697
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNsByHref(xmlDocPtr doc, xmlNodePtr node, const xmlChar *href)
Referenced by xsltCopyOf(), and xsltCopyTreeList().
◆ xsltCopyTreeList()
|
static |
xsltCopyTreeList: @ctxt: a XSLT process context @invocNode: responsible node in the stylesheet; used for error reports @list: the list of element nodes in the source tree. @insert: the parent in the result tree. @isLRE: is this a literal result element list @topElemVisited: indicates if a top-most element was already processed
Make a copy of the full list of tree @list and insert it as last children of @insert
NOTE: Not to be used for Literal Result Elements.
Used by:
Returns a pointer to the new list, or NULL in case of error
Definition at line 1388 of file transform.c.
1391{
1393
1400 }
1401 }
1403 }
1405}
Referenced by xsltCopyOf(), and xsltCopyTree().
◆ xsltCountKeys()
|
static |
Definition at line 5678 of file transform.c.
5679{
5681 xsltKeyDefPtr keyd;
5682
5684 return(-1);
5685
5686 /*
5687 * Do we have those nastly templates with a key() in the match pattern?
5688 */
5689 ctxt->hasTemplKeyPatterns = 0;
5693 ctxt->hasTemplKeyPatterns = 1;
5694 break;
5695 }
5697 }
5698 /*
5699 * Count number of key declarations.
5700 */
5701 ctxt->nbKeys = 0;
5704 keyd = style->keys;
5705 while (keyd) {
5706 ctxt->nbKeys++;
5707 keyd = keyd->next;
5708 }
5710 }
5712}
Definition: xsltInternals.h:349
Referenced by xsltApplyStylesheetInternal().
◆ xsltDebugGetDefaultTrace()
| xsltDebugTraceCodes xsltDebugGetDefaultTrace | ( | void | ) |
xsltDebugGetDefaultTrace:
Get the current default debug tracing level mask
Returns the current default debug tracing level mask
Definition at line 460 of file transform.c.
460 {
462}
◆ xsltDebugSetDefaultTrace()
| void xsltDebugSetDefaultTrace | ( | xsltDebugTraceCodes | val | ) |
xsltDebugSetDefaultTrace: @val: tracing level mask
Set the default debug tracing level mask
Definition at line 449 of file transform.c.
◆ xsltDefaultProcessOneNode()
|
static |
xsltDefaultProcessOneNode: @ctxt: a XSLT process context @node: the node in the source tree. @params: extra parameters passed to the template if any
Process the source node with the default built-in template rule: <xsl:template match="*|/"> <xsl:apply-templates/> </xsl:template>
and
<xsl:template match="text()|@*"> <xsl:value-of select="."/> </xsl:template>
Note also that namespace declarations are copied directly:
the built-in template rule is the only template rule that is applied for namespace nodes.
Definition at line 1859 of file transform.c.
1860 {
1863 int nbchild = 0, oldSize;
1864 int childno = 0, oldPos;
1866
1867 CHECK_STOPPED;
1868 /*
1869 * Handling of leaves
1870 */
1875 break;
1877#ifdef WITH_XSLT_DEBUG_PROCESS
1879 "xsltDefaultProcessOneNode: copy CDATA %s\n",
1880 node->content));
1881#endif
1885 "xsltDefaultProcessOneNode: cdata copy failed\n");
1886 }
1887 return;
1889#ifdef WITH_XSLT_DEBUG_PROCESS
1892 "xsltDefaultProcessOneNode: copy empty text\n"));
1893 return;
1894 } else {
1896 "xsltDefaultProcessOneNode: copy text %s\n",
1897 node->content));
1898 }
1899#endif
1903 "xsltDefaultProcessOneNode: text copy failed\n");
1904 }
1905 return;
1912 "xsltDefaultProcessOneNode: no text for attribute\n");
1913 } else {
1914#ifdef WITH_XSLT_DEBUG_PROCESS
1917 "xsltDefaultProcessOneNode: copy empty text\n"));
1918 } else {
1920 "xsltDefaultProcessOneNode: copy text %s\n",
1921 cur->content));
1922 }
1923#endif
1927 "xsltDefaultProcessOneNode: text copy failed\n");
1928 }
1929 }
1930 return;
1931 default:
1932 return;
1933 }
1934 /*
1935 * Handling of Elements: first pass, counting
1936 */
1940 nbchild++;
1942 }
1943
1944 /*
1945 * Handling of Elements: second pass, actual processing
1946 *
1947 * Note that params are passed to the next template. This matches
1948 * XSLT 2.0 behavior but doesn't conform to XSLT 1.0.
1949 */
1950 oldSize = ctxt->xpathCtxt->contextSize;
1951 oldPos = ctxt->xpathCtxt->proximityPosition;
1954 childno++;
1959 ctxt->xpathCtxt->contextSize = nbchild;
1960 ctxt->xpathCtxt->proximityPosition = childno;
1962 break;
1965 if (template) {
1966#ifdef WITH_XSLT_DEBUG_PROCESS
1968 "xsltDefaultProcessOneNode: applying template for CDATA %s\n",
1969 cur->content));
1970#endif
1971 /*
1972 * Instantiate the xsl:template.
1973 */
1976 } else /* if (ctxt->mode == NULL) */ {
1977#ifdef WITH_XSLT_DEBUG_PROCESS
1979 "xsltDefaultProcessOneNode: copy CDATA %s\n",
1980 cur->content));
1981#endif
1985 "xsltDefaultProcessOneNode: cdata copy failed\n");
1986 }
1987 }
1988 break;
1991 if (template) {
1992#ifdef WITH_XSLT_DEBUG_PROCESS
1994 "xsltDefaultProcessOneNode: applying template for text %s\n",
1995 cur->content));
1996#endif
1997 ctxt->xpathCtxt->contextSize = nbchild;
1998 ctxt->xpathCtxt->proximityPosition = childno;
1999 /*
2000 * Instantiate the xsl:template.
2001 */
2004 } else /* if (ctxt->mode == NULL) */ {
2005#ifdef WITH_XSLT_DEBUG_PROCESS
2008 "xsltDefaultProcessOneNode: copy empty text\n"));
2009 } else {
2011 "xsltDefaultProcessOneNode: copy text %s\n",
2012 cur->content));
2013 }
2014#endif
2018 "xsltDefaultProcessOneNode: text copy failed\n");
2019 }
2020 }
2021 break;
2025 if (template) {
2026#ifdef WITH_XSLT_DEBUG_PROCESS
2029 "xsltDefaultProcessOneNode: template found for PI %s\n",
2030 cur->name));
2033 "xsltDefaultProcessOneNode: template found for comment\n"));
2034 }
2035#endif
2036 ctxt->xpathCtxt->contextSize = nbchild;
2037 ctxt->xpathCtxt->proximityPosition = childno;
2038 /*
2039 * Instantiate the xsl:template.
2040 */
2043 }
2044 break;
2045 default:
2046 break;
2047 }
2049 }
2050 ctxt->xpathCtxt->contextSize = oldSize;
2051 ctxt->xpathCtxt->proximityPosition = oldPos;
2052}
Referenced by xsltApplyImports(), and xsltProcessOneNode().
◆ xsltDocumentElem()
| void xsltDocumentElem | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltDocumentElem: @ctxt: an XSLT processing context @node: The current node @inst: the instruction in the stylesheet @castedComp: precomputed information
Process an EXSLT/XSLT-1.1 document element
Definition at line 3323 of file transform.c.
3325{
3326#ifdef XSLT_REFACTORED
3327 xsltStyleItemDocumentPtr comp = (xsltStyleItemDocumentPtr) castedComp;
3328#else
3330#endif
3336 xmlDocPtr oldOutput;
3338 const char *oldOutputFile;
3339 xsltOutputType oldType;
3346 int redirect_write_append = 0;
3347
3349 return;
3350
3352
3354 /*
3355 * The element "output" is in the namespace XSLT_SAXON_NAMESPACE
3356 * (http://icl.com/saxon)
3357 * The @file is in no namespace.
3358 */
3359#ifdef WITH_XSLT_DEBUG_EXTRA
3361 "Found saxon:output extension\n");
3362#endif
3363 URL = xsltEvalAttrValueTemplate(ctxt, inst,
3365 XSLT_SAXON_NAMESPACE);
3366
3368 URL = xsltEvalAttrValueTemplate(ctxt, inst,
3370 XSLT_SAXON_NAMESPACE);
3372#ifdef WITH_XSLT_DEBUG_EXTRA
3374 "Found xalan:write extension\n");
3375#endif
3376 URL = xsltEvalAttrValueTemplate(ctxt, inst,
3378 "select",
3379 XSLT_XALAN_NAMESPACE);
3381 xmlXPathCompExprPtr cmp;
3383
3384 /*
3385 * Trying to handle bug #59212
3386 * The value of the "select" attribute is an
3387 * XPath expression.
3388 * (see http://xml.apache.org/xalan-j/extensionslib.html#redirect)
3389 */
3392 xmlXPathFreeCompExpr(cmp);
3393 xmlFree(URL);
3394 URL = val;
3395 }
3397 URL = xsltEvalAttrValueTemplate(ctxt, inst,
3399 "file",
3400 XSLT_XALAN_NAMESPACE);
3402 URL = xsltEvalAttrValueTemplate(ctxt, inst,
3404 "href",
3405 XSLT_XALAN_NAMESPACE);
3407 URL = xsltEvalAttrValueTemplate(ctxt, inst,
3409 NULL);
3410 }
3411
3412 } else {
3413 URL = xmlStrdup(comp->filename);
3414 }
3415
3418 "xsltDocumentElem: href/URI-Reference not found\n");
3419 return;
3420 }
3421
3422 /*
3423 * If the computation failed, it's likely that the URL wasn't escaped
3424 */
3427 xmlChar *escURL;
3428
3432 xmlFree(escURL);
3433 }
3434 }
3435
3438 "xsltDocumentElem: URL computation failed for %s\n",
3439 URL);
3440 xmlFree(URL);
3441 return;
3442 }
3443
3444 /*
3445 * Security checking: can we write to this resource
3446 */
3452 "xsltDocumentElem: write rights for %s denied\n",
3453 filename);
3454 xmlFree(URL);
3456 return;
3457 }
3458 }
3459
3460 oldOutputFile = ctxt->outputFile;
3461 oldOutput = ctxt->output;
3462 oldInsert = ctxt->insert;
3463 oldType = ctxt->type;
3465
3469 "xsltDocumentElem: out of memory\n");
3471 }
3472
3473 /*
3474 * Version described in 1.1 draft allows full parameterization
3475 * of the output.
3476 */
3477 prop = xsltEvalAttrValueTemplate(ctxt, inst,
3479 NULL);
3483 style->version = prop;
3484 }
3485 prop = xsltEvalAttrValueTemplate(ctxt, inst,
3487 NULL);
3491 style->encoding = prop;
3492 }
3493 prop = xsltEvalAttrValueTemplate(ctxt, inst,
3495 NULL);
3498
3505
3506 URI = xsltGetQNameURI(inst, &prop);
3513 style->method = prop;
3514 } else {
3516 "invalid value for method: %s\n", prop);
3518 }
3519 } else {
3520 style->method = prop;
3522 }
3523 }
3524 prop = xsltEvalAttrValueTemplate(ctxt, inst,
3530 style->doctypeSystem = prop;
3531 }
3532 prop = xsltEvalAttrValueTemplate(ctxt, inst,
3538 style->doctypePublic = prop;
3539 }
3540 prop = xsltEvalAttrValueTemplate(ctxt, inst,
3542 NULL);
3545 style->standalone = 1;
3547 style->standalone = 0;
3548 } else {
3550 "invalid value for standalone: %s\n",
3551 prop);
3553 }
3554 xmlFree(prop);
3555 }
3556
3557 prop = xsltEvalAttrValueTemplate(ctxt, inst,
3559 NULL);
3562 style->indent = 1;
3564 style->indent = 0;
3565 } else {
3567 "invalid value for indent: %s\n", prop);
3569 }
3570 xmlFree(prop);
3571 }
3572
3573 prop = xsltEvalAttrValueTemplate(ctxt, inst,
3575 "omit-xml-declaration",
3576 NULL);
3579 style->omitXmlDeclaration = 1;
3581 style->omitXmlDeclaration = 0;
3582 } else {
3584 "invalid value for omit-xml-declaration: %s\n",
3585 prop);
3587 }
3588 xmlFree(prop);
3589 }
3590
3591 elements = xsltEvalAttrValueTemplate(ctxt, inst,
3593 "cdata-section-elements",
3594 NULL);
3599 xmlFree(elements);
3600 return;
3601 }
3602
3603 element = elements;
3606 element++;
3608 break;
3611 end++;
3615
3616#ifdef WITH_XSLT_DEBUG_PARSING
3618 "add cdata section output element %s\n",
3619 element);
3620#endif
3622
3626 }
3628 }
3629 xmlFree(elements);
3630 }
3631
3632 /*
3633 * Create a new document tree and process the element template
3634 */
3640
3646 res = htmlNewDoc(doctypeSystem, doctypePublic);
3647 else {
3649#ifdef XSLT_GENERATE_HTML_DOCTYPE
3651#endif
3652 }
3653 res = htmlNewDocNoDtD(doctypeSystem, doctypePublic);
3654 }
3661 "xsltDocumentElem: unsupported method xhtml\n");
3663 res = htmlNewDocNoDtD(doctypeSystem, doctypePublic);
3675#ifdef WITH_XSLT_DEBUG
3677 "reusing transformation dict for output\n");
3678#endif
3679 } else {
3681 "xsltDocumentElem: unsupported method (%s)\n",
3682 method);
3684 }
3685 } else {
3692#ifdef WITH_XSLT_DEBUG
3694 "reusing transformation dict for output\n");
3695#endif
3696 }
3703
3704 /*
3705 * Do some post processing work depending on the generated output
3706 */
3710
3714 doctype = root->name;
3715
3716 /*
3717 * Apply the default selection of the method
3718 */
3722 xmlNodePtr tmp;
3723
3727 break;
3729 break;
3730 tmp = tmp->next;
3731 }
3737 doctypePublic,
3738 doctypeSystem);
3739#ifdef XSLT_GENERATE_HTML_DOCTYPE
3742 &doctypeSystem);
3744 res->intSubset =
3746 doctypePublic,
3747 doctypeSystem);
3748#endif
3749 }
3750 }
3751
3752 }
3758 doctypePublic,
3759 doctypeSystem);
3760 }
3761 }
3762
3763 /*
3764 * Calls to redirect:write also take an optional attribute append.
3765 * Attribute append="true|yes" which will attempt to simply append
3766 * to an existing file instead of always opening a new file. The
3767 * default behavior of always overwriting the file still happens
3768 * if we do not specify append.
3769 * Note that append use will forbid use of remote URI target.
3770 */
3772 NULL);
3776 style->omitXmlDeclaration = 1;
3777 redirect_write_append = 1;
3778 } else
3779 style->omitXmlDeclaration = 0;
3780 xmlFree(prop);
3781 }
3782
3783 if (redirect_write_append) {
3785
3788 ret = -1;
3789 } else {
3792 }
3793 } else {
3795 }
3798 "xsltDocumentElem: unable to save to %s\n",
3799 filename);
3800#ifdef WITH_XSLT_DEBUG_EXTRA
3801 } else {
3804#endif
3805 }
3806
3807 error:
3808 ctxt->output = oldOutput;
3809 ctxt->insert = oldInsert;
3810 ctxt->type = oldType;
3811 ctxt->outputFile = oldOutputFile;
3813 xmlFree(URL);
3820}
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
XMLPUBFUN int XMLCALL xmlHashAddEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, void *userdata)
Definition: hash.c:406
Definition: mbstring.h:19
Definition: reader.c:257
xmlChar * xsltEvalXPathString(xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp)
Definition: templates.c:171
xmlChar * xsltEvalAttrValueTemplate(xsltTransformContextPtr ctxt, xmlNodePtr inst, const xmlChar *name, const xmlChar *ns)
Definition: templates.c:392
XMLPUBFUN xmlChar *XMLCALL xmlURIEscapeStr(const xmlChar *str, const xmlChar *list)
Definition: uri.c:1679
XMLPUBFUN xmlChar *XMLCALL xmlBuildURI(const xmlChar *URI, const xmlChar *base)
Definition: uri.c:1892
XMLPUBFUN xmlChar *XMLCALL xmlStrndup(const xmlChar *cur, int len)
Definition: xmlstring.c:42
const xmlChar * xsltGetQNameURI(xmlNodePtr node, xmlChar **name)
Definition: xsltutils.c:753
int xsltSaveResultToFilename(const char *URL, xmlDocPtr result, xsltStylesheetPtr style, int compression)
Definition: xsltutils.c:1636
int xsltSaveResultToFile(FILE *file, xmlDocPtr result, xsltStylesheetPtr style)
Definition: xsltutils.c:1680
Referenced by xsltNewStylePreComp(), xsltRegisterAllExtras(), and xsltStylePreCompute().
◆ xsltElement()
| void xsltElement | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltElement: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt element node @castedComp: precomputed information
Process the xslt element node on the source node
Definition at line 4017 of file transform.c.
4018 {
4019#ifdef XSLT_REFACTORED
4020 xsltStyleItemElementPtr comp = (xsltStyleItemElementPtr) castedComp;
4021#else
4023#endif
4027 xmlNodePtr oldInsert;
4028
4030 return;
4031
4032 /*
4033 * A comp->has_name == 0 indicates that we need to skip this instruction,
4034 * since it was evaluated to be invalid already during compilation.
4035 */
4036 if (!comp->has_name)
4037 return;
4038
4039 /*
4040 * stack and saves
4041 */
4042 oldInsert = ctxt->insert;
4043
4045 /* TODO: fix attr acquisition wrt to the XSLT namespace */
4046 prop = xsltEvalAttrValueTemplate(ctxt, inst,
4050 "xsl:element: The attribute 'name' is missing.\n");
4052 }
4053 if (xmlValidateQName(prop, 0)) {
4055 "xsl:element: The effective name '%s' is not a "
4056 "valid QName.\n", prop);
4057 /* we fall through to catch any further errors, if possible */
4058 }
4060 xmlFree(prop);
4061 } else {
4062 /*
4063 * The "name" value was static.
4064 */
4065#ifdef XSLT_REFACTORED
4066 prefix = comp->nsPrefix;
4068#else
4070#endif
4071 }
4072
4073 /*
4074 * Create the new element
4075 */
4078 } else {
4080 }
4084 return;
4085 }
4089 "xsl:element : xsltAddChild failed\n");
4090 return;
4091 }
4092
4093 /*
4094 * Namespace
4095 * ---------
4096 */
4097 if (comp->has_ns) {
4099 /*
4100 * No AVT; just plain text for the namespace name.
4101 */
4102 if (comp->ns[0] != 0)
4103 nsName = comp->ns;
4104 } else {
4105 xmlChar *tmpNsName;
4106 /*
4107 * Eval the AVT.
4108 */
4109 /* TODO: check attr acquisition wrt to the XSLT namespace */
4110 tmpNsName = xsltEvalAttrValueTemplate(ctxt, inst,
4112 /*
4113 * SPEC XSLT 1.0:
4114 * "If the string is empty, then the expanded-name of the
4115 * attribute has a null namespace URI."
4116 */
4119 xmlFree(tmpNsName);
4120 }
4121
4124 "xsl:attribute: Namespace http://www.w3.org/2000/xmlns/ "
4125 "forbidden.\n");
4127 }
4131 prefix = NULL;
4132 }
4133 } else {
4135 /*
4136 * SPEC XSLT 1.0:
4137 * "If the namespace attribute is not present, then the QName is
4138 * expanded into an expanded-name using the namespace declarations
4139 * in effect for the xsl:element element, including any default
4140 * namespace declaration.
4141 */
4144 /*
4145 * TODO: Check this in the compilation layer in case it's a
4146 * static value.
4147 */
4150 "xsl:element: The QName '%s:%s' has no "
4151 "namespace binding in scope in the stylesheet; "
4152 "this is an error, since the namespace was not "
4154 }
4155 } else
4156 nsName = ns->href;
4157 }
4158 /*
4159 * Find/create a matching ns-decl in the result tree.
4160 */
4163 /* Don't use a prefix of "xmlns" */
4165
4167
4168 xmlFree(pref);
4169 } else {
4171 copy);
4172 }
4176 {
4177 /*
4178 * "Undeclare" the default namespace.
4179 */
4181 }
4182
4184
4185 if (comp->has_use) {
4188 } else {
4190 /*
4191 * BUG TODO: use-attribute-sets is not a value template.
4192 * use-attribute-sets = qnames
4193 */
4194 attrSets = xsltEvalAttrValueTemplate(ctxt, inst,
4198 xmlFree(attrSets);
4199 }
4200 }
4201 }
4202 /*
4203 * Instantiate the sequence constructor.
4204 */
4207 NULL);
4208
4209error:
4210 ctxt->insert = oldInsert;
4211 return;
4212}
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocNode(xmlDocPtr doc, xmlNsPtr ns, const xmlChar *name, const xmlChar *content)
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocNodeEatName(xmlDocPtr doc, xmlNsPtr ns, xmlChar *name, const xmlChar *content)
const xmlChar * xsltSplitQName(xmlDictPtr dict, const xmlChar *name, const xmlChar **prefix)
Definition: xsltutils.c:720
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltForEach()
| void xsltForEach | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | contextNode, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltForEach: @ctxt: an XSLT transformation context @contextNode: the "current node" in the source tree @inst: the element node of the xsl:for-each instruction @castedComp: the compiled information of the instruction
Process the xslt for-each node on the source node
Definition at line 5361 of file transform.c.
5363{
5364#ifdef XSLT_REFACTORED
5365 xsltStyleItemForEachPtr comp = (xsltStyleItemForEachPtr) castedComp;
5366#else
5368#endif
5373 xmlNodeSetPtr oldList;
5374 int oldXPProximityPosition, oldXPContextSize;
5375 xmlNodePtr oldContextNode;
5376 xsltTemplatePtr oldCurTemplRule;
5377 xmlDocPtr oldXPDoc;
5378 xsltDocumentPtr oldDocInfo;
5379 xmlXPathContextPtr xpctxt;
5380
5383 "xsltForEach(): Bad arguments.\n");
5384 return;
5385 }
5386
5389 "Internal error in xsltForEach(): "
5390 "The XSLT 'for-each' instruction was not compiled.\n");
5391 return;
5392 }
5395 "Internal error in xsltForEach(): "
5396 "The selecting expression of the XSLT 'for-each' "
5397 "instruction was not compiled correctly.\n");
5398 return;
5399 }
5400 xpctxt = ctxt->xpathCtxt;
5401
5402#ifdef WITH_XSLT_DEBUG_PROCESS
5404 "xsltForEach: select %s\n", comp->select));
5405#endif
5406
5407 /*
5408 * Save context states.
5409 */
5410 oldDocInfo = ctxt->document;
5411 oldList = ctxt->nodeList;
5412 oldContextNode = ctxt->node;
5413 /*
5414 * The "current template rule" is cleared for the instantiation of
5415 * xsl:for-each.
5416 */
5417 oldCurTemplRule = ctxt->currentTemplateRule;
5419
5420 oldXPDoc = xpctxt->doc;
5421 oldXPProximityPosition = xpctxt->proximityPosition;
5422 oldXPContextSize = xpctxt->contextSize;
5423
5424 /*
5425 * Evaluate the 'select' expression.
5426 */
5428
5432 else {
5434 "The 'select' expression does not evaluate to a node set.\n");
5435
5436#ifdef WITH_XSLT_DEBUG_PROCESS
5438 "xsltForEach: select didn't evaluate to a node list\n"));
5439#endif
5441 }
5442 } else {
5444 "Failed to evaluate the 'select' expression.\n");
5447 }
5448
5451
5452#ifdef WITH_XSLT_DEBUG_PROCESS
5455#endif
5456
5457 /*
5458 * Set the list; this has to be done already here for xsltDoSortFunction().
5459 */
5461 /*
5462 * Handle xsl:sort instructions and skip them for further processing.
5463 * BUG TODO: We are not using namespaced potentially defined on the
5464 * xsl:sort element; XPath expression might fail.
5465 */
5466 curInst = inst->children;
5468 int nbsorts = 0;
5470
5471 sorts[nbsorts++] = curInst;
5472
5473#ifdef WITH_DEBUGGER
5476#endif
5477
5478 curInst = curInst->next;
5482 "The number of xsl:sort instructions exceeds the "
5483 "maximum (%d) allowed by this processor.\n",
5484 XSLT_MAX_SORT);
5486 } else {
5487 sorts[nbsorts++] = curInst;
5488 }
5489
5490#ifdef WITH_DEBUGGER
5493#endif
5494 curInst = curInst->next;
5495 }
5496 xsltDoSortFunction(ctxt, sorts, nbsorts);
5497 }
5498 xpctxt->contextSize = list->nodeNr;
5499 /*
5500 * Instantiate the sequence constructor for each selected node.
5501 */
5504 /*
5505 * The selected node becomes the "current node".
5506 */
5508 /*
5509 * An xsl:for-each can change the current context doc.
5510 * OPTIMIZE TODO: Get rid of the need to set the context doc.
5511 */
5513 xpctxt->doc = cur->doc;
5514
5515 xpctxt->proximityPosition = i + 1;
5516
5518 }
5519
5520exit:
5521error:
5523 xmlXPathFreeObject(res);
5524 /*
5525 * Restore old states.
5526 */
5527 ctxt->document = oldDocInfo;
5528 ctxt->nodeList = oldList;
5529 ctxt->node = oldContextNode;
5530 ctxt->currentTemplateRule = oldCurTemplRule;
5531
5532 xpctxt->doc = oldXPDoc;
5533 xpctxt->contextSize = oldXPContextSize;
5534 xpctxt->proximityPosition = oldXPProximityPosition;
5535}
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltFreeTransformContext()
| void xsltFreeTransformContext | ( | xsltTransformContextPtr | ctxt | ) |
xsltFreeTransformContext: @ctxt: an XSLT parser context
Free up the memory allocated by @ctxt
Definition at line 689 of file transform.c.
689 {
691 return;
692
693 /*
694 * Shutdown the extension modules associated to the stylesheet
695 * used if needed.
696 */
697 xsltShutdownCtxtExts(ctxt);
698
701 xmlXPathFreeContext(ctxt->xpathCtxt);
702 }
711
716 }
718 }
719 xsltFreeGlobalVariables(ctxt);
720 xsltFreeDocuments(ctxt);
721 xsltFreeCtxtExts(ctxt);
722 xsltFreeRVTs(ctxt);
725#ifdef WITH_XSLT_DEBUG
727 "freeing transformation dictionary\n");
728#endif
730 xmlFree(ctxt);
731}
static void xsltTransformCacheFree(xsltTransformCachePtr cache)
Definition: transform.c:486
void xsltFreeGlobalVariables(xsltTransformContextPtr ctxt)
Definition: variables.c:2227
Referenced by xsltApplyStylesheetInternal(), and xsltNewTransformContext().
◆ xsltGetHTMLIDs()
|
static |
xsltGetHTMLIDs:
- Version
- : the version string @publicID: used to return the public ID @systemID: used to return the system ID
Returns -1 if not found, 0 otherwise and the system and public Identifier for this given verion of HTML
Definition at line 5581 of file transform.c.
5582 {
5585 return(-1);
5587 i++) {
5594 return(0);
5595 }
5596 }
5597 return(-1);
5598}
int __cdecl system(_In_opt_z_ const char *_Command)
Referenced by xsltApplyStylesheetInternal(), and xsltDocumentElem().
◆ xsltGetXIncludeDefault()
xsltGetXIncludeDefault:
Provides the default state for XInclude processing
Returns 0 if there is no processing 1 otherwise
Definition at line 437 of file transform.c.
437 {
439}
Referenced by xsltNewTransformContext().
◆ xsltIf()
| void xsltIf | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | contextNode, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltIf: @ctxt: a XSLT process context @contextNode: the current node in the source tree @inst: the xsl:if instruction @castedComp: compiled information of the instruction
Processes the xsl:if instruction on the source node.
Definition at line 5255 of file transform.c.
5257{
5259
5260#ifdef XSLT_REFACTORED
5261 xsltStyleItemIfPtr comp = (xsltStyleItemIfPtr) castedComp;
5262#else
5264#endif
5265
5267 return;
5270 "Internal error in xsltIf(): "
5271 "The XSLT 'if' instruction was not compiled.\n");
5272 return;
5273 }
5274
5275#ifdef WITH_XSLT_DEBUG_PROCESS
5277 "xsltIf: test %s\n", comp->test));
5278#endif
5279
5280#ifdef XSLT_FAST_IF
5281 {
5283
5285
5286 /*
5287 * Cleanup fragments created during evaluation of the
5288 * "select" expression.
5289 */
5291 xsltReleaseLocalRVTs(ctxt, oldLocalFragmentTop);
5292 }
5293
5294#ifdef WITH_XSLT_DEBUG_PROCESS
5297#endif
5298
5302 }
5304 /*
5305 * Instantiate the sequence constructor of xsl:if.
5306 */
5307 xsltApplySequenceConstructor(ctxt,
5309 }
5310
5311#else /* XSLT_FAST_IF */
5312 {
5313 /*
5314 * OLD CODE:
5315 */
5316 xmlXPathObjectPtr xpobj = xsltPreCompEval(ctxt, contextNode, comp);
5318 if (xpobj->type != XPATH_BOOLEAN)
5319 xpobj = xmlXPathConvertBoolean(xpobj);
5320 if (xpobj->type == XPATH_BOOLEAN) {
5321 res = xpobj->boolval;
5322
5323#ifdef WITH_XSLT_DEBUG_PROCESS
5326#endif
5328 xsltApplySequenceConstructor(ctxt,
5330 }
5331 } else {
5332
5333#ifdef WITH_XSLT_DEBUG_PROCESS
5336 "xsltIf: test didn't evaluate to a boolean\n"));
5337#endif
5339 }
5340 xmlXPathFreeObject(xpobj);
5341 } else {
5343 }
5344 }
5345#endif /* else of XSLT_FAST_IF */
5346
5347error:
5348 return;
5349}
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltLocalVariablePop()
| void xsltLocalVariablePop | ( | xsltTransformContextPtr | ctxt, |
| int | limitNr, | ||
| int | level | ||
| ) |
xsltLocalVariablePop: @ctxt: the transformation context @limitNr: number of variables which should remain @level: the depth in the xsl:template's tree
Pops all variable values at the given @depth from the stack.
Returns the stored variable value NOTE: This is an internal routine and should not be called by users!
Definition at line 150 of file transform.c.
Referenced by xsltApplyOneTemplate(), xsltApplySequenceConstructor(), and xsltApplyStylesheetInternal().
◆ xsltLocalVariablePush()
| int xsltLocalVariablePush | ( | xsltTransformContextPtr | ctxt, |
| xsltStackElemPtr | variable, | ||
| int | level | ||
| ) |
xsltLocalVariablePush: @ctxt: the transformation context @variable: variable to be pushed to the variable stack @level: new value for variable's level
Places the variable onto the local variable stack
Returns: 0 for success, -1 for any error NOTE: This is an internal routine and should not be called by users!
Definition at line 2188 of file transform.c.
2191{
2193 ctxt->varsMax = 10;
2194 ctxt->varsTab =
2199 return (-1);
2200 }
2201 }
2203 ctxt->varsMax *= 2;
2204 ctxt->varsTab =
2206 ctxt->varsMax *
2210 return (-1);
2211 }
2212 }
2216 return(0);
2217}
Referenced by xsltApplyOneTemplate(), and xsltApplyXSLTTemplate().
◆ xsltMessageWrapper()
|
static |
Definition at line 6295 of file transform.c.
Referenced by xsltRegisterAllElement().
◆ xsltNewTransformContext()
| xsltTransformContextPtr xsltNewTransformContext | ( | xsltStylesheetPtr | style, |
| xmlDocPtr | doc | ||
| ) |
xsltNewTransformContext: @style: a parsed XSLT stylesheet @doc: the input document
Create a new XSLT TransformContext
Returns the newly allocated xsltTransformContextPtr or NULL in case of error
Definition at line 536 of file transform.c.
536 {
538 xsltDocumentPtr docu;
540
541 xsltInitGlobals();
542
546 "xsltNewTransformContext : malloc failed\n");
548 }
550
553 goto internal_err;
554 /*
555 * setup of the dictionary must be done early as some of the
556 * processing later like key handling may need it.
557 */
560#ifdef WITH_XSLT_DEBUG
562 "Creating sub-dictionary from stylesheet for transformation\n");
563#endif
564
565 /*
566 * initialize the template stack
567 */
572 "xsltNewTransformContext: out of memory\n");
573 goto internal_err;
574 }
575 cur->templNr = 0;
576 cur->templMax = 5;
579
580 /*
581 * initialize the variables stack
582 */
587 "xsltNewTransformContext: out of memory\n");
588 goto internal_err;
589 }
590 cur->varsNr = 0;
591 cur->varsMax = 10;
593 cur->varsBase = 0;
595
596 /*
597 * the profiling stack is not initialized by default
598 */
600 cur->profNr = 0;
601 cur->profMax = 0;
602 cur->prof = 0;
603
605 cur->xpathCtxt = xmlXPathNewContext(doc);
608 "xsltNewTransformContext : xmlXPathNewContext failed\n");
609 goto internal_err;
610 }
611 /*
612 * Create an XPath cache.
613 */
615 goto internal_err;
616 /*
617 * Initialize the extras array
618 */
625 "xsltNewTransformContext: out of memory\n");
626 goto internal_err;
627 }
633 }
634 } else {
636 cur->extrasNr = 0;
637 cur->extrasMax = 0;
638 }
639
643 /*
644 * Initialize the registered external modules
645 */
647 /*
648 * Setup document element ordering for later efficiencies
649 * (bug 133289)
650 */
652 xmlXPathOrderDocElems(doc);
653 /*
654 * Must set parserOptions before calling xsltNewDocument
655 * (bug 164530)
656 */
661 "xsltNewTransformContext : xsltNewDocument failed\n");
662 goto internal_err;
663 }
664 docu->main = 1;
665 cur->document = docu;
672 cur->keyInitLevel = 0;
673
675
676internal_err:
680}
xsltSecurityPrefsPtr xsltGetDefaultSecurityPrefs(void)
Definition: security.c:163
static xsltTransformCachePtr xsltTransformCacheCreate(void)
Definition: transform.c:471
xsltDocumentPtr xsltNewDocument(xsltTransformContextPtr ctxt, xmlDocPtr doc)
Definition: documents.c:127
Definition: xsltInternals.h:225
xsltTransformContext * xsltTransformContextPtr
Definition: xsltInternals.h:386
Referenced by xsltApplyStylesheetInternal().
◆ xsltNumber()
| void xsltNumber | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltNumber: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt number node @castedComp: precomputed information
Process the xslt number node on the source node
Definition at line 4553 of file transform.c.
4555{
4556#ifdef XSLT_REFACTORED
4557 xsltStyleItemNumberPtr comp = (xsltStyleItemNumberPtr) castedComp;
4558#else
4560#endif
4561 xmlXPathContextPtr xpctxt;
4562 xmlNsPtr *oldXPNamespaces;
4563 int oldXPNsNr;
4564
4567 "xsl:number : compilation failed\n");
4568 return;
4569 }
4570
4572 return;
4573
4574 comp->numdata.doc = inst->doc;
4575 comp->numdata.node = inst;
4576
4577 xpctxt = ctxt->xpathCtxt;
4578 oldXPNsNr = xpctxt->nsNr;
4579 oldXPNamespaces = xpctxt->namespaces;
4580
4581#ifdef XSLT_REFACTORED
4583 xpctxt->namespaces = comp->inScopeNs->list;
4584 xpctxt->nsNr = comp->inScopeNs->xpathNumber;
4585 } else {
4586 xpctxt->namespaces = NULL;
4587 xpctxt->nsNr = 0;
4588 }
4589#else
4590 xpctxt->namespaces = comp->nsList;
4591 xpctxt->nsNr = comp->nsNr;
4592#endif
4593
4595
4596 xpctxt->nsNr = oldXPNsNr;
4597 xpctxt->namespaces = oldXPNamespaces;
4598}
void xsltNumberFormat(xsltTransformContextPtr ctxt, xsltNumberDataPtr data, xmlNodePtr node)
Definition: numbers.c:728
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltPreCompEval()
|
static |
xsltPreCompEval: @ctxt: transform context @node: context node @comp: precompiled expression
Evaluate a precompiled XPath expression.
Definition at line 321 of file transform.c.
322 {
323 xmlXPathObjectPtr res;
324 xmlXPathContextPtr xpctxt;
325 xmlNodePtr oldXPContextNode;
326 xmlNsPtr *oldXPNamespaces;
327 int oldXPProximityPosition, oldXPContextSize, oldXPNsNr;
328
329 xpctxt = ctxt->xpathCtxt;
330 oldXPContextNode = xpctxt->node;
331 oldXPProximityPosition = xpctxt->proximityPosition;
332 oldXPContextSize = xpctxt->contextSize;
333 oldXPNsNr = xpctxt->nsNr;
334 oldXPNamespaces = xpctxt->namespaces;
335
336 xpctxt->node = node;
337#ifdef XSLT_REFACTORED
339 xpctxt->namespaces = comp->inScopeNs->list;
340 xpctxt->nsNr = comp->inScopeNs->xpathNumber;
341 } else {
342 xpctxt->namespaces = NULL;
343 xpctxt->nsNr = 0;
344 }
345#else
346 xpctxt->namespaces = comp->nsList;
347 xpctxt->nsNr = comp->nsNr;
348#endif
349
351
352 xpctxt->node = oldXPContextNode;
353 xpctxt->proximityPosition = oldXPProximityPosition;
354 xpctxt->contextSize = oldXPContextSize;
355 xpctxt->nsNr = oldXPNsNr;
356 xpctxt->namespaces = oldXPNamespaces;
357
359}
Referenced by xsltApplyTemplates(), xsltChoose(), xsltCopyOf(), xsltForEach(), xsltIf(), and xsltValueOf().
◆ xsltPreCompEvalToBoolean()
|
static |
xsltPreCompEvalToBoolean: @ctxt: transform context @node: context node @comp: precompiled expression
Evaluate a precompiled XPath expression as boolean.
Definition at line 370 of file transform.c.
371 {
373 xmlXPathContextPtr xpctxt;
374 xmlNodePtr oldXPContextNode;
375 xmlNsPtr *oldXPNamespaces;
376 int oldXPProximityPosition, oldXPContextSize, oldXPNsNr;
377
378 xpctxt = ctxt->xpathCtxt;
379 oldXPContextNode = xpctxt->node;
380 oldXPProximityPosition = xpctxt->proximityPosition;
381 oldXPContextSize = xpctxt->contextSize;
382 oldXPNsNr = xpctxt->nsNr;
383 oldXPNamespaces = xpctxt->namespaces;
384
385 xpctxt->node = node;
386#ifdef XSLT_REFACTORED
388 xpctxt->namespaces = comp->inScopeNs->list;
389 xpctxt->nsNr = comp->inScopeNs->xpathNumber;
390 } else {
391 xpctxt->namespaces = NULL;
392 xpctxt->nsNr = 0;
393 }
394#else
395 xpctxt->namespaces = comp->nsList;
396 xpctxt->nsNr = comp->nsNr;
397#endif
398
400
401 xpctxt->node = oldXPContextNode;
402 xpctxt->proximityPosition = oldXPProximityPosition;
403 xpctxt->contextSize = oldXPContextSize;
404 xpctxt->nsNr = oldXPNsNr;
405 xpctxt->namespaces = oldXPNamespaces;
406
408}
Referenced by xsltChoose(), and xsltIf().
◆ xsltProcessingInstruction()
| void xsltProcessingInstruction | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltProcessingInstruction: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt processing-instruction node @castedComp: precomputed information
Process the xslt processing-instruction node on the source node
Definition at line 4269 of file transform.c.
4270 {
4271#ifdef XSLT_REFACTORED
4272 xsltStyleItemPIPtr comp = (xsltStyleItemPIPtr) castedComp;
4273#else
4275#endif
4279
4280
4282 return;
4283 if (comp->has_name == 0)
4284 return;
4290 "xsl:processing-instruction : name is missing\n");
4292 }
4293 } else {
4295 }
4296 /* TODO: check that it's both an an NCName and a PITarget. */
4297
4298
4302 "xsl:processing-instruction: '?>' not allowed within PI content\n");
4304 }
4305#ifdef WITH_XSLT_DEBUG_PROCESS
4309 } else {
4312 }
4313#endif
4314
4317
4318error:
4323}
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltProcessOneNode()
| void xsltProcessOneNode | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | contextNode, | ||
| xsltStackElemPtr | withParams | ||
| ) |
xsltProcessOneNode: @ctxt: a XSLT process context @contextNode: the "current node" in the source tree @withParams: extra parameters (e.g. xsl:with-param) passed to the template if any
Process the source node.
Definition at line 2064 of file transform.c.
2066{
2067 xsltTemplatePtr templ;
2068 xmlNodePtr oldNode;
2069
2071 /*
2072 * If no template is found, apply the default rule.
2073 */
2075#ifdef WITH_XSLT_DEBUG_PROCESS
2078 "xsltProcessOneNode: no template found for /\n"));
2081 "xsltProcessOneNode: no template found for CDATA\n"));
2084 "xsltProcessOneNode: no template found for attribute %s\n",
2086 } else {
2089 }
2090#endif
2091 oldNode = ctxt->node;
2092 ctxt->node = contextNode;
2093 xsltDefaultProcessOneNode(ctxt, contextNode, withParams);
2094 ctxt->node = oldNode;
2095 return;
2096 }
2097
2100 /*
2101 * Set the "current template rule".
2102 */
2103 ctxt->currentTemplateRule = templ;
2104
2105#ifdef WITH_XSLT_DEBUG_PROCESS
2107 "xsltProcessOneNode: applying template '%s' for attribute %s\n",
2109#endif
2111
2112 ctxt->currentTemplateRule = oldCurTempRule;
2113 } else {
2115 /*
2116 * Set the "current template rule".
2117 */
2118 ctxt->currentTemplateRule = templ;
2119
2120#ifdef WITH_XSLT_DEBUG_PROCESS
2123 "xsltProcessOneNode: applying template '%s' for /\n",
2124 templ->match));
2125 } else {
2127 "xsltProcessOneNode: applying template '%s' for %s\n",
2129 }
2130#endif
2132
2133 ctxt->currentTemplateRule = oldCurTempRule;
2134 }
2135}
Referenced by xsltApplyStylesheetInternal(), xsltApplyTemplates(), and xsltDefaultProcessOneNode().
◆ xsltProfileStylesheet()
| xmlDocPtr xsltProfileStylesheet | ( | xsltStylesheetPtr | style, |
| xmlDocPtr | doc, | ||
| const char ** | params, | ||
| FILE * | output | ||
| ) |
xsltProfileStylesheet: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated arry of parameters names/values tuples @output: a FILE * for the profiling output
Apply the stylesheet to the document and dump the profiling to the given output.
Returns the result document or NULL in case of error
Definition at line 6163 of file transform.c.
◆ xsltRegisterAllElement()
| void xsltRegisterAllElement | ( | xsltTransformContextPtr | ctxt | ) |
xsltRegisterAllElement: @ctxt: the XPath context
Registers all default XSLT elements in this context
Definition at line 6307 of file transform.c.
6308{
6310 XSLT_NAMESPACE,
6311 xsltApplyTemplates);
6313 XSLT_NAMESPACE,
6314 xsltApplyImports);
6316 XSLT_NAMESPACE,
6317 xsltCallTemplate);
6319 XSLT_NAMESPACE,
6320 xsltElement);
6322 XSLT_NAMESPACE,
6323 xsltAttribute);
6325 XSLT_NAMESPACE,
6326 xsltText);
6328 XSLT_NAMESPACE,
6329 xsltProcessingInstruction);
6331 XSLT_NAMESPACE,
6332 xsltComment);
6334 XSLT_NAMESPACE,
6335 xsltCopy);
6337 XSLT_NAMESPACE,
6338 xsltValueOf);
6340 XSLT_NAMESPACE,
6341 xsltNumber);
6343 XSLT_NAMESPACE,
6344 xsltForEach);
6346 XSLT_NAMESPACE,
6347 xsltIf);
6349 XSLT_NAMESPACE,
6350 xsltChoose);
6352 XSLT_NAMESPACE,
6353 xsltSort);
6355 XSLT_NAMESPACE,
6356 xsltCopyOf);
6358 XSLT_NAMESPACE,
6359 xsltMessageWrapper);
6360
6361 /*
6362 * Those don't have callable entry points but are registered anyway
6363 */
6365 XSLT_NAMESPACE,
6366 xsltDebug);
6368 XSLT_NAMESPACE,
6369 xsltDebug);
6371 XSLT_NAMESPACE,
6372 xsltDebug);
6374 XSLT_NAMESPACE,
6375 xsltDebug);
6377 XSLT_NAMESPACE,
6378 xsltDebug);
6380 XSLT_NAMESPACE,
6381 xsltDebug);
6383 XSLT_NAMESPACE,
6384 xsltDebug);
6385
6386}
int xsltRegisterExtElement(xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *URI, xsltTransformFunction function)
Definition: extensions.c:621
void xsltAttribute(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: attributes.c:716
void xsltForEach(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: transform.c:5361
void xsltCallTemplate(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: transform.c:4679
void xsltValueOf(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: transform.c:4479
void xsltSort(xsltTransformContextPtr ctxt, xmlNodePtr node ATTRIBUTE_UNUSED, xmlNodePtr inst, xsltElemPreCompPtr comp)
Definition: transform.c:3839
void xsltApplyImports(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst, xsltElemPreCompPtr comp ATTRIBUTE_UNUSED)
Definition: transform.c:4610
void xsltProcessingInstruction(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: transform.c:4269
static void xsltMessageWrapper(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp ATTRIBUTE_UNUSED)
Definition: transform.c:6295
void xsltCopyOf(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: transform.c:4335
void xsltElement(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: transform.c:4017
void xsltIf(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: transform.c:5255
void xsltComment(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp ATTRIBUTE_UNUSED)
Definition: transform.c:4225
void xsltChoose(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst, xsltElemPreCompPtr comp ATTRIBUTE_UNUSED)
Definition: transform.c:5096
void xsltText(xsltTransformContextPtr ctxt, xmlNodePtr node ATTRIBUTE_UNUSED, xmlNodePtr inst, xsltElemPreCompPtr comp ATTRIBUTE_UNUSED)
Definition: transform.c:3980
void xsltCopy(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: transform.c:3861
void xsltNumber(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: transform.c:4553
void xsltApplyTemplates(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
Definition: transform.c:4782
◆ xsltReleaseLocalRVTs()
|
static |
xsltReleaseLocalRVTs:
Fragments which are results of extension instructions are preserved; all other fragments are freed/cached.
Definition at line 2226 of file transform.c.
2227{
2229
2231 return;
2234
2235 /* Reset localRVT early because some RVTs might be registered again. */
2239
2240 do {
2241 tmp = cur;
2244 xsltReleaseRVT(ctxt, tmp);
2246 xsltRegisterPersistRVT(ctxt, tmp);
2248 /*
2249 * This will either register the RVT again or move it to the
2250 * context variable.
2251 */
2252 xsltRegisterLocalRVT(ctxt, tmp);
2253 tmp->psvi = XSLT_RVT_FUNC_RESULT;
2254 } else {
2256 "xsltReleaseLocalRVTs: Unexpected RVT flag %p\n",
2257 tmp->psvi);
2258 }
2260}
Definition: uninitialized_test.cpp:81
int xsltRegisterLocalRVT(xsltTransformContextPtr ctxt, xmlDocPtr RVT)
Definition: variables.c:138
int xsltRegisterPersistRVT(xsltTransformContextPtr ctxt, xmlDocPtr RVT)
Definition: variables.c:394
Referenced by xsltApplySequenceConstructor(), xsltApplyStylesheetInternal(), and xsltIf().
◆ xsltRunStylesheet()
| int xsltRunStylesheet | ( | xsltStylesheetPtr | style, |
| xmlDocPtr | doc, | ||
| const char ** | params, | ||
| const char * | output, | ||
| xmlSAXHandlerPtr | SAX, | ||
| xmlOutputBufferPtr | IObuf | ||
| ) |
xsltRunStylesheet: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated array of parameters names/values tuples @output: the URL/filename ot the generated resource if available @SAX: a SAX handler for progressive callback output (not implemented yet) @IObuf: an output buffer for progressive output (not implemented yet)
Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf.
NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8
Returns the number of bytes written to the main resource or -1 in case of error.
Definition at line 6286 of file transform.c.
6289{
6292}
int xsltRunStylesheetUser(xsltStylesheetPtr style, xmlDocPtr doc, const char **params, const char *output, xmlSAXHandlerPtr SAX, xmlOutputBufferPtr IObuf, FILE *profile, xsltTransformContextPtr userCtxt)
Definition: transform.c:6225
◆ xsltRunStylesheetUser()
| int xsltRunStylesheetUser | ( | xsltStylesheetPtr | style, |
| xmlDocPtr | doc, | ||
| const char ** | params, | ||
| const char * | output, | ||
| xmlSAXHandlerPtr | SAX, | ||
| xmlOutputBufferPtr | IObuf, | ||
| FILE * | profile, | ||
| xsltTransformContextPtr | userCtxt | ||
| ) |
xsltRunStylesheetUser: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated array of parameters names/values tuples @output: the URL/filename ot the generated resource if available @SAX: a SAX handler for progressive callback output (not implemented yet) @IObuf: an output buffer for progressive output (not implemented yet) @profile: profile FILE * output or NULL @userCtxt: user provided transform context
Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf.
NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8
Returns the number of by written to the main resource or -1 in case of error.
Definition at line 6225 of file transform.c.
6229{
6230 xmlDocPtr tmp;
6232
6234 return (-1);
6236 return (-1);
6237
6238 /* unsupported yet */
6241 return (-1);
6242 }
6243
6245 userCtxt);
6248 "xsltRunStylesheet : run failed\n");
6249 return (-1);
6250 }
6252 /* TODO: incomplete, IObuf output not progressive */
6254 } else {
6256 }
6257 xmlFreeDoc(tmp);
6259}
int xsltSaveResultTo(xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style)
Definition: xsltutils.c:1460
Referenced by xsltRunStylesheet().
◆ xsltSetXIncludeDefault()
xsltSetXIncludeDefault: @xinclude: whether to do XInclude processing
Set whether XInclude should be processed on document being loaded by default
Definition at line 425 of file transform.c.
◆ xsltShallowCopyAttr()
|
static |
xsltShallowCopyAttr: @ctxt: a XSLT process context @invocNode: responsible node in the stylesheet; used for error reports @target: the element where the attribute will be grafted @attr: the attribute to be copied
Do a copy of an attribute. Called by:
Returns: a new xmlAttrPtr, or NULL in case of error.
Definition at line 1121 of file transform.c.
1123{
1126
1129
1132 "Cannot add an attribute node to a non-element node.\n");
1134 }
1135
1138 "Attribute nodes must be added before "
1139 "any child nodes to an element.\n");
1141 }
1142
1146
1151 "Namespace fixup error: Failed to acquire an in-scope "
1152 "namespace binding of the copied attribute '{%s}%s'.\n",
1154 /*
1155 * TODO: Should we just stop here?
1156 */
1157 }
1158 /*
1159 * Note that xmlSetNsProp() will take care of duplicates
1160 * and assigns the new namespace even to a duplicate.
1161 */
1163 } else {
1165 }
1168
1171
1172#if 0
1173 /*
1174 * NOTE: This was optimized according to bug #342695.
1175 * TODO: Can this further be optimized, if source and target
1176 * share the same dict and attr->children is just 1 text node
1177 * which is in the dict? How probable is such a case?
1178 */
1179 /*
1180 * TODO: Do we need to create an empty text node if the value
1181 * is the empty string?
1182 */
1190 {
1191 txtNode->content =
1195 } else
1196 txtNode->content = value;
1197 copy->children = txtNode;
1198 }
1199#endif
1200
1202}
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocText(const xmlDoc *doc, const xmlChar *content)
Referenced by xsltCopy(), xsltCopyOf(), and xsltCopyTree().
◆ xsltShallowCopyElem()
|
static |
xsltShallowCopyElem: @ctxt: the XSLT process context @node: the element node in the source tree or the Literal Result Element @insert: the parent in the result tree @isLRE: if @node is a Literal Result Element
Make a copy of the element node @node and insert it as last child of @insert.
URGENT TODO: The problem with this one (for the non-refactored code) is that it is used for both, Literal Result Elements and copying input nodes.
BIG NOTE: This is only called for XML_ELEMENT_NODEs.
Called from: xsltApplySequenceConstructor() (for Literal Result Elements - which is a problem) xsltCopy() (for shallow-copying elements via xsl:copy)
Returns a pointer to the new node, or NULL in case of error
Definition at line 1296 of file transform.c.
1298{
1300
1306
1313 "xsltShallowCopyElem: copy failed\n");
1315 }
1316
1318 /*
1319 * Add namespaces as they are needed
1320 */
1322 /*
1323 * TODO: Remove the LRE case in the refactored code
1324 * gets enabled.
1325 */
1326 if (isLRE)
1328 else
1330 }
1331
1332 /*
1333 * URGENT TODO: The problem with this is that it does not
1334 * copy over all namespace nodes in scope.
1335 * The damn thing about this is, that we would need to
1336 * use the xmlGetNsList(), for every single node; this is
1337 * also done in xsltCopyTree(), but only for the top node.
1338 */
1340 if (isLRE) {
1341 /*
1342 * REVISIT TODO: Since the non-refactored code still does
1343 * ns-aliasing, we need to call xsltGetNamespace() here.
1344 * Remove this when ready.
1345 */
1347 } else {
1350
1351 }
1354 {
1355 /*
1356 * "Undeclare" the default namespace.
1357 */
1359 }
1360 }
1361 } else {
1364 }
1366}
Referenced by xsltApplySequenceConstructor(), and xsltCopy().
◆ xsltShallowCopyNsNode()
|
static |
xsltShallowCopyNsNode: @ctxt: the XSLT transformation context @invocNode: responsible node in the stylesheet; used for error reports @insert: the target element node in the result tree @ns: the namespace node
This is used for copying ns-nodes with xsl:copy-of and xsl:copy.
Returns a new/existing ns-node, or NULL.
Definition at line 1481 of file transform.c.
1485{
1486 /*
1487 * TODO: Contrary to header comments, this is declared as int.
1488 * be modified to return a node pointer, or NULL if any error
1489 */
1490 xmlNsPtr tmpns;
1491
1494
1497 "Namespace nodes must be added before "
1498 "any child nodes are added to an element.\n");
1500 }
1501 /*
1502 * BIG NOTE: Xalan-J simply overwrites any ns-decls with
1503 * an equal prefix. We definitively won't do that.
1504 *
1505 * MSXML 4.0 and the .NET ignores ns-decls for which an
1506 * equal prefix is already in use.
1507 *
1508 * Saxon raises an error like:
1509 * "net.sf.saxon.xpath.DynamicError: Cannot create two namespace
1510 * nodes with the same name".
1511 *
1512 * NOTE: We'll currently follow MSXML here.
1513 * REVISIT TODO: Check if it's better to follow Saxon here.
1514 */
1516 /*
1517 * If we are adding ns-nodes to an element using e.g.
1518 * <xsl:copy-of select="/foo/namespace::*">, then we need
1519 * to ensure that we don't incorrectly declare a default
1520 * namespace on an element in no namespace, which otherwise
1521 * would move the element incorrectly into a namespace, if
1522 * the node tree is serialized.
1523 */
1525 goto occupied;
1528 {
1529 /*
1530 * The XML namespace is built in.
1531 */
1533 }
1534
1536 tmpns = insert->nsDef;
1537 do {
1541 {
1542 /*
1543 * Same prefix.
1544 */
1547 goto occupied;
1548 }
1549 }
1550 tmpns = tmpns->next;
1552 }
1556 /*
1557 * Declare a new namespace.
1558 * TODO: The problem (wrt efficiency) with this xmlNewNs() is
1559 * that it will again search the already declared namespaces
1560 * for a duplicate :-/
1561 */
1563
1564occupied:
1565 /*
1566 * TODO: We could as well raise an error here (like Saxon does),
1567 * or at least generate a warning.
1568 */
1570}
Referenced by xsltCopy(), and xsltCopyTree().
◆ xsltSort()
| void xsltSort | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr node | ATTRIBUTE_UNUSED, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | comp | ||
| ) |
xsltSort: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt sort node @comp: precomputed information
function attached to xsl:sort nodes, but this should not be called directly
Definition at line 3839 of file transform.c.
3841 {
3844 "xsl:sort : compilation failed\n");
3845 return;
3846 }
3848 "xsl:sort : improper use this should not be reached\n");
3849}
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltTemplateParamsCleanup()
|
static |
xsltTemplateParamsCleanup:
Removes xsl:param and xsl:with-param items from the variable-stack. Only xsl:with-param items are not freed.
Definition at line 180 of file transform.c.
181{
183
186 /*
187 * Free xsl:param items.
188 * xsl:with-param items will have a level of -1 or -2.
189 */
192 }
193 }
196 else
198}
Referenced by xsltApplyXSLTTemplate().
◆ xsltText()
| void xsltText | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr node | ATTRIBUTE_UNUSED, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr comp | ATTRIBUTE_UNUSED | ||
| ) |
xsltText: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt text node @comp: precomputed information
Process the xslt text node on the source node
Definition at line 3980 of file transform.c.
3981 {
3985
3990 "xsl:text content problem\n");
3991 break;
3992 }
3995#ifdef WITH_XSLT_DEBUG_PARSING
3998#endif
4000 }
4003 }
4004 }
4005}
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
◆ xsltTransformCacheCreate()
|
static |
Definition at line 471 of file transform.c.
472{
474
478 "xsltTransformCacheCreate : malloc failed\n");
480 }
483}
Definition: xsltInternals.h:1644
Referenced by xsltNewTransformContext().
◆ xsltTransformCacheFree()
|
static |
Definition at line 486 of file transform.c.
487{
489 return;
490 /*
491 * Free tree fragments.
492 */
496 tmp = cur;
499 /*
500 * Tree the document info.
501 */
504 }
505 xmlFreeDoc(tmp);
506 }
507 }
508 /*
509 * Free vars/params.
510 */
514 tmp = cur;
516 /*
517 * REVISIT TODO: Should be call a destruction-function
518 * instead?
519 */
520 xmlFree(tmp);
521 }
522 }
524}
Definition: cache.c:49
Referenced by xsltFreeTransformContext().
◆ xsltValueOf()
| void xsltValueOf | ( | xsltTransformContextPtr | ctxt, |
| xmlNodePtr | node, | ||
| xmlNodePtr | inst, | ||
| xsltElemPreCompPtr | castedComp | ||
| ) |
xsltValueOf: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt value-of node @castedComp: precomputed information
Process the xslt value-of node on the source node
Definition at line 4479 of file transform.c.
4481{
4482#ifdef XSLT_REFACTORED
4483 xsltStyleItemValueOfPtr comp = (xsltStyleItemValueOfPtr) castedComp;
4484#else
4486#endif
4489
4491 return;
4492
4495 "Internal error in xsltValueOf(): "
4496 "The XSLT 'value-of' instruction was not compiled.\n");
4497 return;
4498 }
4499
4500#ifdef WITH_XSLT_DEBUG_PROCESS
4502 "xsltValueOf: select %s\n", comp->select));
4503#endif
4504
4506
4507 /*
4508 * Cast the XPath object to string.
4509 */
4514 "Internal error in xsltValueOf(): "
4515 "failed to cast an XPath object to string.\n");
4518 }
4521 }
4522 } else {
4524 "XPath evaluation returned no result.\n");
4527 }
4528
4529#ifdef WITH_XSLT_DEBUG_PROCESS
4533 }
4534#endif
4535
4536error:
4540 xmlXPathFreeObject(res);
4541}
Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().
Variable Documentation
◆ xsltDefaultTrace
|
static |
Definition at line 441 of file transform.c.
Referenced by xsltDebugGetDefaultTrace(), xsltDebugSetDefaultTrace(), and xsltNewTransformContext().
◆ xsltDoXIncludeDefault
|
static |
Definition at line 416 of file transform.c.
Referenced by xsltGetXIncludeDefault(), and xsltSetXIncludeDefault().
◆ xsltHTMLVersions
|
static |
Initial value:
= {
{ "4.01frame", "-//W3C//DTD HTML 4.01 Frameset//EN",
"http://www.w3.org/TR/1999/REC-html401-19991224/frameset.dtd"},
{ "4.01strict", "-//W3C//DTD HTML 4.01//EN",
"http://www.w3.org/TR/1999/REC-html401-19991224/strict.dtd"},
{ "4.01trans", "-//W3C//DTD HTML 4.01 Transitional//EN",
"http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd"},
{ "4.01", "-//W3C//DTD HTML 4.01 Transitional//EN",
"http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd"},
{ "4.0strict", "-//W3C//DTD HTML 4.01//EN",
"http://www.w3.org/TR/html4/strict.dtd"},
{ "4.0trans", "-//W3C//DTD HTML 4.01 Transitional//EN",
"http://www.w3.org/TR/html4/loose.dtd"},
{ "4.0frame", "-//W3C//DTD HTML 4.01 Frameset//EN",
"http://www.w3.org/TR/html4/frameset.dtd"},
{ "4.0", "-//W3C//DTD HTML 4.01 Transitional//EN",
"http://www.w3.org/TR/html4/loose.dtd"},
}
Definition at line 5550 of file transform.c.
Referenced by xsltGetHTMLIDs().
◆ xsltMaxDepth
| int xsltMaxDepth = 3000 |
Definition at line 35 of file transform.c.
Referenced by xsltNewTransformContext().
◆ xsltMaxVars
| int xsltMaxVars = 15000 |
Definition at line 36 of file transform.c.
Referenced by xsltNewTransformContext().
