nokogiri 1.6.1 → 1.6.2.rc1

data/ports/patches/libxslt/0002-Fix-a-couple-of-places-where-f-printf-parameters-wer.patch

@@ -0,0 +1,53 @@
+From 90e8b9066d877e040e791bbf206db0e5653e017a Mon Sep 17 00:00:00 2001
+From: Daniel Veillard <veillard@redhat.com>
+Date: Wed, 30 Jan 2013 17:31:37 +0100
+Subject: [PATCH 02/14] Fix a couple of places where (f)printf parameters were
+ broken
+
+As reported by Thomas Jarosch <thomas.jarosch@intra2net.com>
+---
+ python/libxslt.c    | 10 +++++-----
+ xsltproc/xsltproc.c |  2 +-
+ 2 files changed, 6 insertions(+), 6 deletions(-)
+
+diff --git a/python/libxslt.c b/python/libxslt.c
+index 6a4f1c3..8dd6c78 100644
+--- a/python/libxslt.c
++++ b/python/libxslt.c
+@@ -356,15 +356,15 @@ libxslt_xsltRegisterExtModuleElement(PyObject *self ATTRIBUTE_UNUSED,
+     PyObject *pyobj_element_f;
+     PyObject *pyobj_precomp_f;
+ 
+-#ifdef DEBUG_EXTENSIONS
+-    printf("libxslt_xsltRegisterExtModuleElement called\n",
+-	   name, ns_uri);
+-#endif
+-
+     if (!PyArg_ParseTuple(args, (char *)"szOO:registerExtModuleElement",
+ 		          &name, &ns_uri, &pyobj_precomp_f, &pyobj_element_f))
+         return(NULL);
+ 
++#ifdef DEBUG_EXTENSIONS
++    printf("libxslt_xsltRegisterExtModuleElement called: %s %s\n",
++	   name, ns_uri);
++#endif
++
+     if ((name == NULL) || (pyobj_element_f == NULL) || (pyobj_precomp_f == NULL)) {
+ 	py_retval = libxml_intWrap(-1);
+ 	return(py_retval);
+diff --git a/xsltproc/xsltproc.c b/xsltproc/xsltproc.c
+index 35f37e8..dfd6d31 100644
+--- a/xsltproc/xsltproc.c
++++ b/xsltproc/xsltproc.c
+@@ -319,7 +319,7 @@ static void endTimer(char *format, ...)
+     va_start(ap, format);
+     vfprintf(stderr,format,ap);
+     va_end(ap);
+-    fprintf(stderr, " was not timed\n", msec);
++    fprintf(stderr, " was not timed\n");
+ #else
+   /* We don't have gettimeofday, time or stdarg.h, what crazy world is
+    * this ?!
+-- 
+1.8.4.1
+

data/ports/patches/libxslt/0003-Initialize-pseudo-random-number-generator-with-curre.patch

@@ -0,0 +1,60 @@
+From 3fcf11ead6ad226227b0a3ef4cc6565b8d5857ff Mon Sep 17 00:00:00 2001
+From: Nils Werner <wernerns@iis.fraunhofer.de>
+Date: Thu, 24 Jan 2013 19:44:03 +0100
+Subject: [PATCH 03/14] Initialize pseudo random number generator with current
+ time or optional command line parameter
+
+---
+ xsltproc/xsltproc.c | 15 +++++++++++++++
+ 1 file changed, 15 insertions(+)
+
+diff --git a/xsltproc/xsltproc.c b/xsltproc/xsltproc.c
+index dfd6d31..45adf5d 100644
+--- a/xsltproc/xsltproc.c
++++ b/xsltproc/xsltproc.c
+@@ -514,6 +514,7 @@ static void usage(const char *name) {
+     printf("\t--maxdepth val : increase the maximum depth (default %d)\n", xsltMaxDepth);
+     printf("\t--maxvars val : increase the maximum variables (default %d)\n", xsltMaxVars);
+     printf("\t--maxparserdepth val : increase the maximum parser depth\n");
++    printf("\t--seed-rand val : initialize pseudo random number generator with specific seed\n");
+ #ifdef LIBXML_HTML_ENABLED
+     printf("\t--html: the input document is(are) an HTML file(s)\n");
+ #endif
+@@ -556,6 +557,7 @@ main(int argc, char **argv)
+         return (1);
+     }
+ 
++    srand(time(NULL));
+     xmlInitMemory();
+ 
+     LIBXML_TEST_VERSION
+@@ -750,6 +752,15 @@ main(int argc, char **argv)
+                 if (value > 0)
+                     xmlParserMaxDepth = value;
+             }
++        } else if ((!strcmp(argv[i], "-seed-rand")) ||
++                   (!strcmp(argv[i], "--seed-rand"))) {
++            int value;
++
++            i++;
++            if (sscanf(argv[i], "%d", &value) == 1) {
++                if (value > 0)
++                    srand(value);
++            }
+         } else if ((!strcmp(argv[i],"-dumpextensions"))||
+ 			(!strcmp(argv[i],"--dumpextensions"))) {
+ 		dumpextensions++;
+@@ -786,6 +797,10 @@ main(int argc, char **argv)
+             (!strcmp(argv[i], "--maxparserdepth"))) {
+             i++;
+             continue;
++        } else if ((!strcmp(argv[i], "-seed-rand")) ||
++            (!strcmp(argv[i], "--seed-rand"))) {
++            i++;
++            continue;
+         } else if ((!strcmp(argv[i], "-o")) ||
+                    (!strcmp(argv[i], "-output")) ||
+                    (!strcmp(argv[i], "--output"))) {
+-- 
+1.8.4.1
+

data/ports/patches/libxslt/0004-EXSLT-function-str-replace-is-broken-as-is.patch

@@ -0,0 +1,42 @@
+From ae49d7a73b043bccb7631e7d9577bcaa0bbf8528 Mon Sep 17 00:00:00 2001
+From: Nick Wellnhofer <wellnhofer@aevum.de>
+Date: Mon, 1 Jul 2013 21:10:10 +0800
+Subject: [PATCH 04/14] EXSLT function str:replace() is broken as-is
+
+the str:replace() function is no longer usable without a transform
+context. I take it from the bug report that it is not supposed to be used
+from plain XPath but only from XSLT according to the EXSLT specification.
+
+However, the previous implementation used to work in XPath and is still
+registered on an xmlXPathContext by the exsltStrXpathCtxtRegister()
+function. When called from plain XPath, it results in a memory error in
+line 526 (exsltStrReturnString()) of strings.c because xsltCreateRVT()
+returns NULL as an error indicator due to a NULL transform context being
+passed in, which was the return value from xsltXPathGetTransformContext() a
+bit further up (and the code doesn't validate that).
+
+Since fixing the function looks impossible, best is to remove it.
+---
+ libexslt/strings.c | 6 +-----
+ 1 file changed, 1 insertion(+), 5 deletions(-)
+
+diff --git a/libexslt/strings.c b/libexslt/strings.c
+index 045cc14..c0c7a18 100644
+--- a/libexslt/strings.c
++++ b/libexslt/strings.c
+@@ -838,11 +838,7 @@ exsltStrXpathCtxtRegister (xmlXPathContextPtr ctxt, const xmlChar *prefix)
+         && !xmlXPathRegisterFuncNS(ctxt,
+                                    (const xmlChar *) "concat",
+                                    (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
+-                                   exsltStrConcatFunction)
+-        && !xmlXPathRegisterFuncNS(ctxt,
+-                                   (const xmlChar *) "replace",
+-                                   (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
+-                                   exsltStrReplaceFunction)) {
++                                   exsltStrConcatFunction)) {
+         return 0;
+     }
+     return -1;
+-- 
+1.8.4.1
+

data/ports/patches/libxslt/0006-Fix-str-padding-to-work-with-UTF-8-strings.patch

@@ -0,0 +1,164 @@
+From 515283959aae470a6ee5033deb9f977a489e7578 Mon Sep 17 00:00:00 2001
+From: Nick Wellnhofer <wellnhofer@aevum.de>
+Date: Sun, 4 Aug 2013 16:42:51 +0200
+Subject: [PATCH 06/14] Fix str:padding to work with UTF-8 strings
+
+Thanks to Tobias Hoffmann for the report.
+
+Also add some tests.
+---
+ libexslt/strings.c                | 16 +++++++++-------
+ tests/exslt/strings/padding.1.out | 27 ++++++++++++++++++++++++++
+ tests/exslt/strings/padding.1.xml | 10 ++++++++++
+ tests/exslt/strings/padding.1.xsl | 40 +++++++++++++++++++++++++++++++++++++++
+ 4 files changed, 86 insertions(+), 7 deletions(-)
+ create mode 100644 tests/exslt/strings/padding.1.out
+ create mode 100644 tests/exslt/strings/padding.1.xml
+ create mode 100644 tests/exslt/strings/padding.1.xsl
+
+diff --git a/libexslt/strings.c b/libexslt/strings.c
+index c0c7a18..3c702ad 100644
+--- a/libexslt/strings.c
++++ b/libexslt/strings.c
+@@ -351,8 +351,8 @@ exsltStrDecodeUriFunction (xmlXPathParserContextPtr ctxt, int nargs) {
+  */
+ static void
+ exsltStrPaddingFunction (xmlXPathParserContextPtr ctxt, int nargs) {
+-    int number, str_len = 0;
+-    xmlChar *str = NULL, *ret = NULL, *tmp;
++    int number, str_len = 0, str_size = 0;
++    xmlChar *str = NULL, *ret = NULL;
+ 
+     if ((nargs < 1) || (nargs > 2)) {
+ 	xmlXPathSetArityError(ctxt);
+@@ -362,11 +362,13 @@ exsltStrPaddingFunction (xmlXPathParserContextPtr ctxt, int nargs) {
+     if (nargs == 2) {
+ 	str = xmlXPathPopString(ctxt);
+ 	str_len = xmlUTF8Strlen(str);
++	str_size = xmlStrlen(str);
+     }
+     if (str_len == 0) {
+ 	if (str != NULL) xmlFree(str);
+ 	str = xmlStrdup((const xmlChar *) " ");
+ 	str_len = 1;
++	str_size = 1;
+     }
+ 
+     number = (int) xmlXPathPopNumber(ctxt);
+@@ -378,13 +380,13 @@ exsltStrPaddingFunction (xmlXPathParserContextPtr ctxt, int nargs) {
+     }
+ 
+     while (number >= str_len) {
+-	ret = xmlStrncat(ret, str, str_len);
++	ret = xmlStrncat(ret, str, str_size);
+ 	number -= str_len;
+     }
+-    tmp = xmlUTF8Strndup (str, number);
+-    ret = xmlStrcat(ret, tmp);
+-    if (tmp != NULL)
+-	xmlFree (tmp);
++    if (number > 0) {
++	str_size = xmlUTF8Strsize(str, number);
++	ret = xmlStrncat(ret, str, str_size);
++    }
+ 
+     xmlXPathReturnString(ctxt, ret);
+ 
+diff --git a/tests/exslt/strings/padding.1.out b/tests/exslt/strings/padding.1.out
+new file mode 100644
+index 0000000..1833a65
+--- /dev/null
++++ b/tests/exslt/strings/padding.1.out
+@@ -0,0 +1,27 @@
++<?xml version="1.0"?>
++<test-results>
++  <test-result>
++    <padding>     </padding>
++    <length-check>OK</length-check>
++  </test-result>
++  <test-result>
++    <padding>--------</padding>
++    <length-check>OK</length-check>
++  </test-result>
++  <test-result>
++    <padding>abcabcabca</padding>
++    <length-check>OK</length-check>
++  </test-result>
++  <test-result>
++    <padding>–––––––</padding>
++    <length-check>OK</length-check>
++  </test-result>
++  <test-result>
++    <padding>– – – – – –</padding>
++    <length-check>OK</length-check>
++  </test-result>
++  <test-result>
++    <padding>ÄÖÜÄÖÜ</padding>
++    <length-check>OK</length-check>
++  </test-result>
++</test-results>
+diff --git a/tests/exslt/strings/padding.1.xml b/tests/exslt/strings/padding.1.xml
+new file mode 100644
+index 0000000..16d0824
+--- /dev/null
++++ b/tests/exslt/strings/padding.1.xml
+@@ -0,0 +1,10 @@
++<?xml version="1.0"?>
++<test-cases>
++    <test-case length="5"/>
++    <test-case length="8">-</test-case>
++    <test-case length="10">abc</test-case>
++    <test-case length="7">&#x2013;</test-case>
++    <test-case length="11">&#x2013;&#xa0;</test-case>
++    <test-case length="6">ÄÖÜ</test-case>
++</test-cases>
++
+diff --git a/tests/exslt/strings/padding.1.xsl b/tests/exslt/strings/padding.1.xsl
+new file mode 100644
+index 0000000..c5d621d
+--- /dev/null
++++ b/tests/exslt/strings/padding.1.xsl
+@@ -0,0 +1,40 @@
++<?xml version="1.0"?>
++<xsl:stylesheet version="1.0"
++    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
++    xmlns:str="http://exslt.org/strings"
++    exclude-result-prefixes="str">
++
++<xsl:output indent="yes"/>
++
++<xsl:template match="test-cases">
++    <test-results>
++        <xsl:apply-templates select="test-case"/>
++    </test-results>
++</xsl:template>
++
++<xsl:template match="test-case">
++    <test-result>
++        <xsl:variable name="padding">
++            <xsl:choose>
++                <xsl:when test="string(.)">
++                    <xsl:value-of select="str:padding(@length, .)"/>
++                </xsl:when>
++                <xsl:otherwise>
++                    <xsl:value-of select="str:padding(@length)"/>
++                </xsl:otherwise>
++            </xsl:choose>
++        </xsl:variable>
++        <padding>
++            <xsl:value-of select="$padding"/>
++        </padding>
++        <length-check>
++            <xsl:choose>
++                <xsl:when test="string-length($padding) = @length">OK</xsl:when>
++                <xsl:otherwise>FAIL</xsl:otherwise>
++            </xsl:choose>
++        </length-check>
++    </test-result>
++</xsl:template>
++
++</xsl:stylesheet>
++
+-- 
+1.8.4.1
+

data/ports/patches/libxslt/0007-Separate-function-for-predicate-matching-in-patterns.patch

@@ -0,0 +1,587 @@
+From a0116212e6dde5efe311e8240e45ae1477f8988f Mon Sep 17 00:00:00 2001
+From: Nick Wellnhofer <wellnhofer@aevum.de>
+Date: Sun, 4 Aug 2013 20:28:19 +0200
+Subject: [PATCH 07/14] Separate function for predicate matching in patterns
+
+No functional change, only make the predicate matching code more
+readable.
+---
+ libxslt/pattern.c | 546 +++++++++++++++++++++++++++---------------------------
+ 1 file changed, 274 insertions(+), 272 deletions(-)
+
+diff --git a/libxslt/pattern.c b/libxslt/pattern.c
+index 63ec25a..414363b 100644
+--- a/libxslt/pattern.c
++++ b/libxslt/pattern.c
+@@ -621,6 +621,278 @@ xsltTestCompMatchDirect(xsltTransformContextPtr ctxt, xsltCompMatchPtr comp,
+ }
+ 
+ /**
++ * xsltTestPredicateMatch:
++ * @ctxt: a XSLT process context
++ * @comp: the precompiled pattern
++ * @node: a node
++ * @step: the predicate step
++ * @sel:  the previous step
++ *
++ * Test whether the node matches the predicate
++ *
++ * Returns 1 if it matches, 0 if it doesn't and -1 in case of failure
++ */
++static int
++xsltTestPredicateMatch(xsltTransformContextPtr ctxt, xsltCompMatchPtr comp,
++                       xmlNodePtr node, xsltStepOpPtr step,
++                       xsltStepOpPtr sel) {
++    xmlNodePtr oldNode;
++    xmlDocPtr doc;
++    int oldCS, oldCP;
++    int pos = 0, len = 0;
++    int isRVT;
++    int match;
++
++    if (step->value == NULL)
++        return(0);
++    if (step->comp == NULL)
++        return(0);
++
++    doc = node->doc;
++    if (XSLT_IS_RES_TREE_FRAG(doc))
++        isRVT = 1;
++    else
++        isRVT = 0;
++
++    /*
++     * Depending on the last selection, one may need to
++     * recompute contextSize and proximityPosition.
++     */
++    oldCS = ctxt->xpathCtxt->contextSize;
++    oldCP = ctxt->xpathCtxt->proximityPosition;
++    if ((sel != NULL) &&
++        (sel->op == XSLT_OP_ELEM) &&
++        (sel->value != NULL) &&
++        (node->type == XML_ELEMENT_NODE) &&
++        (node->parent != NULL)) {
++        xmlNodePtr previous;
++        int nocache = 0;
++
++        previous = (xmlNodePtr)
++            XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr);
++        if ((previous != NULL) &&
++            (previous->parent == node->parent)) {
++            /*
++             * just walk back to adjust the index
++             */
++            int indx = 0;
++            xmlNodePtr sibling = node;
++
++            while (sibling != NULL) {
++                if (sibling == previous)
++                    break;
++                if ((sibling->type == XML_ELEMENT_NODE) &&
++                    (previous->name != NULL) &&
++                    (sibling->name != NULL) &&
++                    (previous->name[0] == sibling->name[0]) &&
++                    (xmlStrEqual(previous->name, sibling->name)))
++                {
++                    if ((sel->value2 == NULL) ||
++                        ((sibling->ns != NULL) &&
++                         (xmlStrEqual(sel->value2, sibling->ns->href))))
++                        indx++;
++                }
++                sibling = sibling->prev;
++            }
++            if (sibling == NULL) {
++                /* hum going backward in document order ... */
++                indx = 0;
++                sibling = node;
++                while (sibling != NULL) {
++                    if (sibling == previous)
++                        break;
++                    if ((sibling->type == XML_ELEMENT_NODE) &&
++                        (previous->name != NULL) &&
++                        (sibling->name != NULL) &&
++                        (previous->name[0] == sibling->name[0]) &&
++                        (xmlStrEqual(previous->name, sibling->name)))
++                    {
++                        if ((sel->value2 == NULL) ||
++                            ((sibling->ns != NULL) &&
++                            (xmlStrEqual(sel->value2,
++                            sibling->ns->href))))
++                        {
++                            indx--;
++                        }
++                    }
++                    sibling = sibling->next;
++                }
++            }
++            if (sibling != NULL) {
++                pos = XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) + indx;
++                /*
++                 * If the node is in a Value Tree we need to
++                 * save len, but cannot cache the node!
++                 * (bugs 153137 and 158840)
++                 */
++                if (node->doc != NULL) {
++                    len = XSLT_RUNTIME_EXTRA(ctxt, sel->lenExtra, ival);
++                    if (!isRVT) {
++                        XSLT_RUNTIME_EXTRA(ctxt,
++                            sel->previousExtra, ptr) = node;
++                        XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) = pos;
++                    }
++                }
++            } else
++                pos = 0;
++        } else {
++            /*
++             * recompute the index
++             */
++            xmlNodePtr parent = node->parent;
++            xmlNodePtr siblings = NULL;
++
++            if (parent) siblings = parent->children;
++
++            while (siblings != NULL) {
++                if (siblings->type == XML_ELEMENT_NODE) {
++                    if (siblings == node) {
++                        len++;
++                        pos = len;
++                    } else if ((node->name != NULL) &&
++                               (siblings->name != NULL) &&
++                        (node->name[0] == siblings->name[0]) &&
++                        (xmlStrEqual(node->name, siblings->name))) {
++                        if ((sel->value2 == NULL) ||
++                            ((siblings->ns != NULL) &&
++                             (xmlStrEqual(sel->value2, siblings->ns->href))))
++                            len++;
++                    }
++                }
++                siblings = siblings->next;
++            }
++            if ((parent == NULL) || (node->doc == NULL))
++                nocache = 1;
++            else {
++                while (parent->parent != NULL)
++                    parent = parent->parent;
++                if (((parent->type != XML_DOCUMENT_NODE) &&
++                     (parent->type != XML_HTML_DOCUMENT_NODE)) ||
++                     (parent != (xmlNodePtr) node->doc))
++                    nocache = 1;
++            }
++        }
++        if (pos != 0) {
++            ctxt->xpathCtxt->contextSize = len;
++            ctxt->xpathCtxt->proximityPosition = pos;
++            /*
++             * If the node is in a Value Tree we cannot
++             * cache it !
++             */
++            if ((!isRVT) && (node->doc != NULL) &&
++                (nocache == 0)) {
++                XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr) = node;
++                XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) = pos;
++                XSLT_RUNTIME_EXTRA(ctxt, sel->lenExtra, ival) = len;
++            }
++        }
++    } else if ((sel != NULL) && (sel->op == XSLT_OP_ALL) &&
++               (node->type == XML_ELEMENT_NODE)) {
++        xmlNodePtr previous;
++        int nocache = 0;
++
++        previous = (xmlNodePtr)
++            XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr);
++        if ((previous != NULL) &&
++            (previous->parent == node->parent)) {
++            /*
++             * just walk back to adjust the index
++             */
++            int indx = 0;
++            xmlNodePtr sibling = node;
++
++            while (sibling != NULL) {
++                if (sibling == previous)
++                    break;
++                if (sibling->type == XML_ELEMENT_NODE)
++                    indx++;
++                sibling = sibling->prev;
++            }
++            if (sibling == NULL) {
++                /* hum going backward in document order ... */
++                indx = 0;
++                sibling = node;
++                while (sibling != NULL) {
++                    if (sibling == previous)
++                        break;
++                    if (sibling->type == XML_ELEMENT_NODE)
++                        indx--;
++                    sibling = sibling->next;
++                }
++            }
++            if (sibling != NULL) {
++                pos = XSLT_RUNTIME_EXTRA(ctxt,
++                    sel->indexExtra, ival) + indx;
++                /*
++                 * If the node is in a Value Tree we cannot
++                 * cache it !
++                 */
++                if ((node->doc != NULL) && !isRVT) {
++                    len = XSLT_RUNTIME_EXTRA(ctxt, sel->lenExtra, ival);
++                    XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr) = node;
++                    XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) = pos;
++                }
++            } else
++                pos = 0;
++        } else {
++            /*
++             * recompute the index
++             */
++            xmlNodePtr parent = node->parent;
++            xmlNodePtr siblings = NULL;
++
++            if (parent) siblings = parent->children;
++
++            while (siblings != NULL) {
++                if (siblings->type == XML_ELEMENT_NODE) {
++                    len++;
++                    if (siblings == node) {
++                        pos = len;
++                    }
++                }
++                siblings = siblings->next;
++            }
++            if ((parent == NULL) || (node->doc == NULL))
++                nocache = 1;
++            else {
++                while (parent->parent != NULL)
++                    parent = parent->parent;
++                if (((parent->type != XML_DOCUMENT_NODE) &&
++                     (parent->type != XML_HTML_DOCUMENT_NODE)) ||
++                     (parent != (xmlNodePtr) node->doc))
++                    nocache = 1;
++            }
++        }
++        if (pos != 0) {
++            ctxt->xpathCtxt->contextSize = len;
++            ctxt->xpathCtxt->proximityPosition = pos;
++            /*
++             * If the node is in a Value Tree we cannot
++             * cache it !
++             */
++            if ((node->doc != NULL) && (nocache == 0) && !isRVT) {
++                XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr) = node;
++                XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) = pos;
++                XSLT_RUNTIME_EXTRA(ctxt, sel->lenExtra, ival) = len;
++            }
++        }
++    }
++
++    oldNode = ctxt->node;
++    ctxt->node = node;
++
++    match = xsltEvalXPathPredicate(ctxt, step->comp, comp->nsList, comp->nsNr);
++
++    if (pos != 0) {
++        ctxt->xpathCtxt->contextSize = oldCS;
++        ctxt->xpathCtxt->proximityPosition = oldCP;
++    }
++    ctxt->node = oldNode;
++
++    return match;
++}
++
++/**
+  * xsltTestCompMatch:
+  * @ctxt:  a XSLT process context
+  * @comp: the precompiled pattern
+@@ -854,12 +1126,6 @@ restart:
+ 		    goto rollback;
+ 		break;
+ 	    case XSLT_OP_PREDICATE: {
+-		xmlNodePtr oldNode;
+-		xmlDocPtr doc;
+-		int oldCS, oldCP;
+-		int pos = 0, len = 0;
+-		int isRVT;
+-
+ 		/*
+ 		 * when there is cascading XSLT_OP_PREDICATE, then use a
+ 		 * direct computation approach. It's not done directly
+@@ -875,274 +1141,10 @@ restart:
+ 						   comp->nsList, comp->nsNr));
+ 		}
+ 
+-		doc = node->doc;
+-		if (XSLT_IS_RES_TREE_FRAG(doc))
+-		    isRVT = 1;
+-		else
+-		    isRVT = 0;
+-
+-		/*
+-		 * Depending on the last selection, one may need to
+-		 * recompute contextSize and proximityPosition.
+-		 */
+-		oldCS = ctxt->xpathCtxt->contextSize;
+-		oldCP = ctxt->xpathCtxt->proximityPosition;
+-		if ((sel != NULL) &&
+-		    (sel->op == XSLT_OP_ELEM) &&
+-		    (sel->value != NULL) &&
+-		    (node->type == XML_ELEMENT_NODE) &&
+-		    (node->parent != NULL)) {
+-		    xmlNodePtr previous;
+-		    int nocache = 0;
+-
+-		    previous = (xmlNodePtr)
+-			XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr);
+-		    if ((previous != NULL) &&
+-			(previous->parent == node->parent)) {
+-			/*
+-			 * just walk back to adjust the index
+-			 */
+-			int indx = 0;
+-			xmlNodePtr sibling = node;
+-
+-			while (sibling != NULL) {
+-			    if (sibling == previous)
+-				break;
+-			    if ((sibling->type == XML_ELEMENT_NODE) &&
+-				(previous->name != NULL) &&
+-				(sibling->name != NULL) &&
+-				(previous->name[0] == sibling->name[0]) &&
+-				(xmlStrEqual(previous->name, sibling->name)))
+-			    {
+-				if ((sel->value2 == NULL) ||
+-				    ((sibling->ns != NULL) &&
+-				     (xmlStrEqual(sel->value2,
+-						  sibling->ns->href))))
+-				    indx++;
+-			    }
+-			    sibling = sibling->prev;
+-			}
+-			if (sibling == NULL) {
+-			    /* hum going backward in document order ... */
+-			    indx = 0;
+-			    sibling = node;
+-			    while (sibling != NULL) {
+-				if (sibling == previous)
+-				    break;
+-				if ((sibling->type == XML_ELEMENT_NODE) &&
+-				    (previous->name != NULL) &&
+-				    (sibling->name != NULL) &&
+-				    (previous->name[0] == sibling->name[0]) &&
+-				    (xmlStrEqual(previous->name, sibling->name)))
+-				{
+-				    if ((sel->value2 == NULL) ||
+-					((sibling->ns != NULL) &&
+-					(xmlStrEqual(sel->value2,
+-					sibling->ns->href))))
+-				    {
+-					indx--;
+-				    }
+-				}
+-				sibling = sibling->next;
+-			    }
+-			}
+-			if (sibling != NULL) {
+-		            pos = XSLT_RUNTIME_EXTRA(ctxt,
+-                                sel->indexExtra, ival) + indx;
+-			    /*
+-			     * If the node is in a Value Tree we need to
+-			     * save len, but cannot cache the node!
+-			     * (bugs 153137 and 158840)
+-			     */
+-			    if (node->doc != NULL) {
+-				len = XSLT_RUNTIME_EXTRA(ctxt,
+-				        sel->lenExtra, ival);
+-				if (!isRVT) {
+-				    XSLT_RUNTIME_EXTRA(ctxt,
+-					sel->previousExtra, ptr) = node;
+-				    XSLT_RUNTIME_EXTRA(ctxt,
+-				        sel->indexExtra, ival) = pos;
+-				}
+-			    }
+-			} else
+-			    pos = 0;
+-		    } else {
+-			/*
+-			 * recompute the index
+-			 */
+-			xmlNodePtr parent = node->parent;
+-			xmlNodePtr siblings = NULL;
+-
+-                        if (parent) siblings = parent->children;
+-
+-			while (siblings != NULL) {
+-			    if (siblings->type == XML_ELEMENT_NODE) {
+-				if (siblings == node) {
+-				    len++;
+-				    pos = len;
+-				} else if ((node->name != NULL) &&
+-					   (siblings->name != NULL) &&
+-				    (node->name[0] == siblings->name[0]) &&
+-				    (xmlStrEqual(node->name, siblings->name))) {
+-				    if ((sel->value2 == NULL) ||
+-					((siblings->ns != NULL) &&
+-					 (xmlStrEqual(sel->value2,
+-						      siblings->ns->href))))
+-					len++;
+-				}
+-			    }
+-			    siblings = siblings->next;
+-			}
+-			if ((parent == NULL) || (node->doc == NULL))
+-			    nocache = 1;
+-			else {
+-			    while (parent->parent != NULL)
+-				parent = parent->parent;
+-			    if (((parent->type != XML_DOCUMENT_NODE) &&
+-				 (parent->type != XML_HTML_DOCUMENT_NODE)) ||
+-				 (parent != (xmlNodePtr) node->doc))
+-				nocache = 1;
+-			}
+-		    }
+-		    if (pos != 0) {
+-			ctxt->xpathCtxt->contextSize = len;
+-			ctxt->xpathCtxt->proximityPosition = pos;
+-			/*
+-			 * If the node is in a Value Tree we cannot
+-			 * cache it !
+-			 */
+-			if ((!isRVT) && (node->doc != NULL) &&
+-			    (nocache == 0)) {
+-			    XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr) =
+-				node;
+-			    XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) =
+-				pos;
+-			    XSLT_RUNTIME_EXTRA(ctxt, sel->lenExtra, ival) =
+-				len;
+-			}
+-		    }
+-		} else if ((sel != NULL) && (sel->op == XSLT_OP_ALL) &&
+-			   (node->type == XML_ELEMENT_NODE)) {
+-		    xmlNodePtr previous;
+-		    int nocache = 0;
+-
+-		    previous = (xmlNodePtr)
+-			XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr);
+-		    if ((previous != NULL) &&
+-			(previous->parent == node->parent)) {
+-			/*
+-			 * just walk back to adjust the index
+-			 */
+-			int indx = 0;
+-			xmlNodePtr sibling = node;
+-
+-			while (sibling != NULL) {
+-			    if (sibling == previous)
+-				break;
+-			    if (sibling->type == XML_ELEMENT_NODE)
+-				indx++;
+-			    sibling = sibling->prev;
+-			}
+-			if (sibling == NULL) {
+-			    /* hum going backward in document order ... */
+-			    indx = 0;
+-			    sibling = node;
+-			    while (sibling != NULL) {
+-				if (sibling == previous)
+-				    break;
+-				if (sibling->type == XML_ELEMENT_NODE)
+-				    indx--;
+-				sibling = sibling->next;
+-			    }
+-			}
+-			if (sibling != NULL) {
+-			    pos = XSLT_RUNTIME_EXTRA(ctxt,
+-                                sel->indexExtra, ival) + indx;
+-			    /*
+-			     * If the node is in a Value Tree we cannot
+-			     * cache it !
+-			     */
+-			    if ((node->doc != NULL) && !isRVT) {
+-				len = XSLT_RUNTIME_EXTRA(ctxt,
+-				        sel->lenExtra, ival);
+-				XSLT_RUNTIME_EXTRA(ctxt,
+-					sel->previousExtra, ptr) = node;
+-				XSLT_RUNTIME_EXTRA(ctxt,
+-					sel->indexExtra, ival) = pos;
+-			    }
+-			} else
+-			    pos = 0;
+-		    } else {
+-			/*
+-			 * recompute the index
+-			 */
+-			xmlNodePtr parent = node->parent;
+-			xmlNodePtr siblings = NULL;
+-
+-                        if (parent) siblings = parent->children;
+-
+-			while (siblings != NULL) {
+-			    if (siblings->type == XML_ELEMENT_NODE) {
+-				len++;
+-				if (siblings == node) {
+-				    pos = len;
+-				}
+-			    }
+-			    siblings = siblings->next;
+-			}
+-			if ((parent == NULL) || (node->doc == NULL))
+-			    nocache = 1;
+-			else {
+-			    while (parent->parent != NULL)
+-				parent = parent->parent;
+-			    if (((parent->type != XML_DOCUMENT_NODE) &&
+-				 (parent->type != XML_HTML_DOCUMENT_NODE)) ||
+-				 (parent != (xmlNodePtr) node->doc))
+-				nocache = 1;
+-			}
+-		    }
+-		    if (pos != 0) {
+-			ctxt->xpathCtxt->contextSize = len;
+-			ctxt->xpathCtxt->proximityPosition = pos;
+-			/*
+-			 * If the node is in a Value Tree we cannot
+-			 * cache it !
+-			 */
+-			if ((node->doc != NULL) && (nocache == 0) && !isRVT) {
+-			    XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr) =
+-				node;
+-			    XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) =
+-				pos;
+-			    XSLT_RUNTIME_EXTRA(ctxt, sel->lenExtra, ival) =
+-				len;
+-			}
+-		    }
+-		}
+-		oldNode = ctxt->node;
+-		ctxt->node = node;
+-
+-		if (step->value == NULL)
+-		    goto wrong_index;
+-		if (step->comp == NULL)
+-		    goto wrong_index;
+-
+-		if (!xsltEvalXPathPredicate(ctxt, step->comp, comp->nsList,
+-			                    comp->nsNr))
+-		    goto wrong_index;
++		if (!xsltTestPredicateMatch(ctxt, comp, node, step, sel))
++		    goto rollback;
+ 
+-		if (pos != 0) {
+-		    ctxt->xpathCtxt->contextSize = oldCS;
+-		    ctxt->xpathCtxt->proximityPosition = oldCP;
+-		}
+-		ctxt->node = oldNode;
+ 		break;
+-wrong_index:
+-		if (pos != 0) {
+-		    ctxt->xpathCtxt->contextSize = oldCS;
+-		    ctxt->xpathCtxt->proximityPosition = oldCP;
+-		}
+-		ctxt->node = oldNode;
+-		goto rollback;
+ 	    }
+             case XSLT_OP_PI:
+ 		if (node->type != XML_PI_NODE)
+-- 
+1.8.4.1
+