Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxslt/libxslt/pattern.c

 /*
  * pattern.c: Implemetation of the template match compilation and lookup
  *
  * Reference:
  *   http://www.w3.org/TR/1999/REC-xslt-19991116
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 /*
  * TODO: handle pathological cases like *[*[@a="b"]]
  * TODO: detect [number] at compilation, optimize accordingly
  */
 
 #define IN_LIBXSLT
 #include "libxslt.h"
 
 #include <string.h>
 
 #include <libxml/xmlmemory.h>
 #include <libxml/tree.h>
 #include <libxml/valid.h>
 #include <libxml/hash.h>
 #include <libxml/xmlerror.h>
 #include <libxml/parserInternals.h>
+#include <libxml/xpath.h>
 #include "xslt.h"
 #include "xsltInternals.h"
 #include "xsltutils.h"
 #include "imports.h"
 #include "templates.h"
 #include "keys.h"
 #include "pattern.h"
 #include "documents.h"
 
 #ifdef WITH_XSLT_DEBUG
@@ skipping 82 matching lines @@
     xsltTransformContextPtr ctxt;       /* the transformation or NULL */
     const xmlChar *cur;                 /* the current char being parsed */
     const xmlChar *base;                /* the full expression */
     xmlDocPtr      doc;                 /* the source document */
     xmlNodePtr    elem;                 /* the source element */
     int error;                          /* error code */
     xsltCompMatchPtr comp;              /* the result */
 };
 
 /************************************************************************
- *                                                                      *
- *                      Type functions                                  *
- *                                                                      *
+ *                                                                      *
+ *                      Type functions                                  *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xsltNewCompMatch:
  *
  * Create a new XSLT CompMatch
  *
  * Returns the newly allocated xsltCompMatchPtr or NULL in case of error
  */
 static xsltCompMatchPtr
@@ skipping 153 matching lines @@
     if (comp->nbStep >= comp->maxStep) {
         xsltStepOpPtr tmp;
 
         tmp = (xsltStepOpPtr) xmlRealloc(comp->steps, comp->maxStep * 2 *
                                          sizeof(xsltStepOp));
         if (tmp == NULL) {
             xsltGenericError(xsltGenericErrorContext,
              "xsltCompMatchAdd: memory re-allocation failure.\n");
             if (ctxt->style != NULL)
                 ctxt->style->errors++;
+            if (value)
+                xmlFree(value);
+            if (value2)
+                xmlFree(value2);
             return (-1);
         }
         comp->maxStep *= 2;
         comp->steps = tmp;
     }
     comp->steps[comp->nbStep].op = op;
     comp->steps[comp->nbStep].value = value;
     comp->steps[comp->nbStep].value2 = value2;
     comp->steps[comp->nbStep].value3 = NULL;
     comp->steps[comp->nbStep].comp = NULL;
@@ skipping 45 matching lines @@
  * reverse the two top steps.
  */
 static void
 xsltSwapTopCompMatch(xsltCompMatchPtr comp) {
     int i;
     int j = comp->nbStep - 1;
 
     if (j > 0) {
         register xmlChar *tmp;
         register xsltOp op;
-        register xmlXPathCompExprPtr expr; 
+        register xmlXPathCompExprPtr expr;
         register int t;
         i = j - 1;
         tmp = comp->steps[i].value;
         comp->steps[i].value = comp->steps[j].value;
         comp->steps[j].value = tmp;
         tmp = comp->steps[i].value2;
         comp->steps[i].value2 = comp->steps[j].value2;
         comp->steps[j].value2 = tmp;
         tmp = comp->steps[i].value3;
         comp->steps[i].value3 = comp->steps[j].value3;
@@ skipping 57 matching lines @@
         comp->steps[j].indexExtra = t;
         t = comp->steps[i].lenExtra;
         comp->steps[i].lenExtra = comp->steps[j].lenExtra;
         comp->steps[j].lenExtra = t;
         j--;
         i++;
     }
     xsltCompMatchAdd(ctxt, comp, XSLT_OP_END, NULL, NULL, 0);
 
     /*
-     * detect consecutive XSLT_OP_PREDICATE indicating a direct
-     * matching should be done.
+     * Detect consecutive XSLT_OP_PREDICATE and predicates on ops which
+     * haven't been optimized yet indicating a direct matching should be done.
      */
     for (i = 0;i < comp->nbStep - 1;i++) {
-        if ((comp->steps[i].op == XSLT_OP_PREDICATE) &&
+        xsltOp op = comp->steps[i].op;
+
+        if ((op != XSLT_OP_ELEM) &&
+            (op != XSLT_OP_ALL) &&
             (comp->steps[i + 1].op == XSLT_OP_PREDICATE)) {
 
             comp->direct = 1;
             if (comp->pattern[0] != '/') {
                 xmlChar *query;
 
                 query = xmlStrdup((const xmlChar *)"//");
                 query = xmlStrcat(query, comp->pattern);
 
                 xmlFree((xmlChar *) comp->pattern);
                 comp->pattern = query;
             }
             break;
         }
     }
 }
 
 /************************************************************************
- *                                                                      *
- *              The interpreter for the precompiled patterns            *
- *                                                                      *
+ *                                                                      *
+ *              The interpreter for the precompiled patterns            *
+ *                                                                      *
  ************************************************************************/
 
 static int
 xsltPatPushState(xsltTransformContextPtr ctxt, xsltStepStates *states,
                  int step, xmlNodePtr node) {
     if ((states->states == NULL) || (states->maxstates <= 0)) {
         states->maxstates = 4;
         states->nbstates = 0;
         states->states = xmlMalloc(4 * sizeof(xsltStepState));
     }
@@ skipping 48 matching lines @@
         isRVT = 1;
     else
         isRVT = 0;
     sel = &comp->steps[0]; /* store extra in first step arbitrarily */
 
     prevdoc = (xmlDocPtr)
         XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr);
     ix = XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival);
     list = (xmlXPathObjectPtr)
         XSLT_RUNTIME_EXTRA_LST(ctxt, sel->lenExtra);
-    
+
     if ((list == NULL) || (prevdoc != doc)) {
         xmlXPathObjectPtr newlist;
         xmlNodePtr parent = node->parent;
         xmlDocPtr olddoc;
         xmlNodePtr oldnode;
-        int oldNsNr;
+        int oldNsNr, oldContextSize, oldProximityPosition;
         xmlNsPtr *oldNamespaces;
 
         oldnode = ctxt->xpathCtxt->node;
         olddoc = ctxt->xpathCtxt->doc;
         oldNsNr = ctxt->xpathCtxt->nsNr;
         oldNamespaces = ctxt->xpathCtxt->namespaces;
+        oldContextSize = ctxt->xpathCtxt->contextSize;
+        oldProximityPosition = ctxt->xpathCtxt->proximityPosition;
         ctxt->xpathCtxt->node = node;
         ctxt->xpathCtxt->doc = doc;
         ctxt->xpathCtxt->namespaces = nsList;
         ctxt->xpathCtxt->nsNr = nsNr;
         newlist = xmlXPathEval(comp->pattern, ctxt->xpathCtxt);
         ctxt->xpathCtxt->node = oldnode;
         ctxt->xpathCtxt->doc = olddoc;
         ctxt->xpathCtxt->namespaces = oldNamespaces;
         ctxt->xpathCtxt->nsNr = oldNsNr;
+        ctxt->xpathCtxt->contextSize = oldContextSize;
+        ctxt->xpathCtxt->proximityPosition = oldProximityPosition;
         if (newlist == NULL)
             return(-1);
         if (newlist->type != XPATH_NODESET) {
             xmlXPathFreeObject(newlist);
             return(-1);
         }
         ix = 0;
 
         if ((parent == NULL) || (node->doc == NULL) || isRVT)
             nocache = 1;
-        
+
         if (nocache == 0) {
             if (list != NULL)
                 xmlXPathFreeObject(list);
             list = newlist;
 
             XSLT_RUNTIME_EXTRA_LST(ctxt, sel->lenExtra) =
                 (void *) list;
             XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr) =
                 (void *) doc;
             XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) =
@@ skipping 19 matching lines @@
             }
         }
     } else {
     }
     if (nocache == 1)
         xmlXPathFreeObject(list);
     return(0);
 }
 
 /**
+ * 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;
+
+    /*
+     * Recompute contextSize and proximityPosition.
+     *
+     * TODO: Make this work for additional ops. Currently, only XSLT_OP_ELEM
+     * and XSLT_OP_ALL are supported.
+     */
+    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
  * @node: a node
  * @mode:  the mode name or NULL
  * @modeURI:  the mode URI or NULL
  *
  * Test whether the node matches the pattern
  *
  * Returns 1 if it matches, 0 if it doesn't and -1 in case of failure
  */
 static int
 xsltTestCompMatch(xsltTransformContextPtr ctxt, xsltCompMatchPtr comp,
-                  xmlNodePtr node, const xmlChar *mode,
+                  xmlNodePtr matchNode, const xmlChar *mode,
                   const xmlChar *modeURI) {
     int i;
+    xmlNodePtr node = matchNode;
     xsltStepOpPtr step, sel = NULL;
     xsltStepStates states = {0, 0, NULL}; /* // may require backtrack */
 
     if ((comp == NULL) || (node == NULL) || (ctxt == NULL)) {
         xsltTransformError(ctxt, NULL, node,
                 "xsltTestCompMatch: null arg\n");
         return(-1);
     }
     if (mode != NULL) {
         if (comp->mode == NULL)
@@ skipping 106 matching lines @@
                         goto rollback;
                 }
                 continue;
             case XSLT_OP_ANCESTOR:
                 /* TODO: implement coalescing of ANCESTOR/NODE ops */
                 if (step->value == NULL) {
                     step = &comp->steps[i+1];
                     if (step->op == XSLT_OP_ROOT)
                         goto found;
                     /* added NS, ID and KEY as a result of bug 168208 */
-                    if ((step->op != XSLT_OP_ELEM) && 
-                        (step->op != XSLT_OP_ALL) && 
+                    if ((step->op != XSLT_OP_ELEM) &&
+                        (step->op != XSLT_OP_ALL) &&
                         (step->op != XSLT_OP_NS) &&
                         (step->op != XSLT_OP_ID) &&
                         (step->op != XSLT_OP_KEY))
                         goto rollback;
                 }
                 if (node == NULL)
                     goto rollback;
                 if ((node->type == XML_DOCUMENT_NODE) ||
                     (node->type == XML_HTML_DOCUMENT_NODE) ||
 #ifdef LIBXML_DOCB_ENABLED
@@ skipping 69 matching lines @@
                         goto rollback;
                     if (!xmlStrEqual(step->value, node->ns->href))
                         goto rollback;
                 }
                 break;
             case XSLT_OP_ALL:
                 if (node->type != XML_ELEMENT_NODE)
                     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
+                 * When there is cascading XSLT_OP_PREDICATE or a predicate
+                 * after an op which hasn't been optimized yet, then use a
                  * direct computation approach. It's not done directly
                  * at the beginning of the routine to filter out as much
                  * as possible this costly computation.
                  */
                 if (comp->direct) {
                     if (states.states != NULL) {
                         /* Free the rollback states */
                         xmlFree(states.states);
                     }
-                    return(xsltTestCompMatchDirect(ctxt, comp, node,
-                                                   comp->nsList, comp->nsNr));
+                    return(xsltTestCompMatchDirect(ctxt, comp, matchNode,
+                                                   comp->nsList, comp->nsNr));
                 }
 
-                doc = node->doc;
-                if (XSLT_IS_RES_TREE_FRAG(doc))
-                    isRVT = 1;
-                else
-                    isRVT = 0;
+                if (!xsltTestPredicateMatch(ctxt, comp, node, step, sel))
+                    goto rollback;
 
-                /*
-                 * 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 ix, nocache = 0;
-
-                    previous = (xmlNodePtr)
-                        XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr);
-                    ix = XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival);
-                    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 ((previous->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 ((previous->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 = ix + 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;
-                                }
-                            }
-                            ix = 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 ix, nocache = 0;
-
-                    previous = (xmlNodePtr)
-                        XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr);
-                    ix = XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival);
-                    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 = ix + 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 (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)
                     goto rollback;
                 if (step->value != NULL) {
                     if (!xmlStrEqual(step->value, node->name))
                         goto rollback;
                 }
                 break;
             case XSLT_OP_COMMENT:
@@ skipping 72 matching lines @@
  *                                                                      *
  *                      Dedicated parser for templates                  *
  *                                                                      *
  ************************************************************************/
 
 #define CUR (*ctxt->cur)
 #define SKIP(val) ctxt->cur += (val)
 #define NXT(val) ctxt->cur[(val)]
 #define CUR_PTR ctxt->cur
 
-#define SKIP_BLANKS                                                     \
+#define SKIP_BLANKS                                                     \
     while (IS_BLANK_CH(CUR)) NEXT
 
 #define CURRENT (*ctxt->cur)
 #define NEXT ((*ctxt->cur) ?  ctxt->cur++: ctxt->cur)
 
 
-#define PUSH(op, val, val2, novar)                                              \
+#define PUSH(op, val, val2, novar)                                              \
     if (xsltCompMatchAdd(ctxt, ctxt->comp, (op), (val), (val2), (novar))) goto error;
 
-#define SWAP()                                          \
+#define SWAP()                                          \
     xsltSwapTopCompMatch(ctxt->comp);
 
 #define XSLT_ERROR(X)                                                   \
     { xsltError(ctxt, __FILE__, __LINE__, X);                   \
       ctxt->error = (X); return; }
 
 #define XSLT_ERROR0(X)                                                  \
     { xsltError(ctxt, __FILE__, __LINE__, X);                   \
       ctxt->error = (X); return(0); }
 
@@ skipping 123 matching lines @@
     if ((aid) && (xmlStrEqual(name, (const xmlChar *)"id"))) {
         if (axis != 0) {
             xsltTransformError(NULL, NULL, NULL,
                     "xsltCompileIdKeyPattern : NodeTest expected\n");
             ctxt->error = 1;
             return;
         }
         NEXT;
         SKIP_BLANKS;
         lit = xsltScanLiteral(ctxt);
-        if (ctxt->error)
+        if (ctxt->error) {
+            xsltTransformError(NULL, NULL, NULL,
+                    "xsltCompileIdKeyPattern : Literal expected\n");
             return;
+        }
         SKIP_BLANKS;
         if (CUR != ')') {
             xsltTransformError(NULL, NULL, NULL,
                     "xsltCompileIdKeyPattern : ) expected\n");
+            xmlFree(lit);
             ctxt->error = 1;
             return;
         }
         NEXT;
         PUSH(XSLT_OP_ID, lit, NULL, novar);
+        lit = NULL;
     } else if ((aid) && (xmlStrEqual(name, (const xmlChar *)"key"))) {
         if (axis != 0) {
             xsltTransformError(NULL, NULL, NULL,
                     "xsltCompileIdKeyPattern : NodeTest expected\n");
             ctxt->error = 1;
             return;
         }
         NEXT;
         SKIP_BLANKS;
         lit = xsltScanLiteral(ctxt);
-        if (ctxt->error)
+        if (ctxt->error) {
+            xsltTransformError(NULL, NULL, NULL,
+                    "xsltCompileIdKeyPattern : Literal expected\n");
             return;
+        }
         SKIP_BLANKS;
         if (CUR != ',') {
             xsltTransformError(NULL, NULL, NULL,
                     "xsltCompileIdKeyPattern : , expected\n");
+            xmlFree(lit);
             ctxt->error = 1;
             return;
         }
         NEXT;
         SKIP_BLANKS;
         lit2 = xsltScanLiteral(ctxt);
-        if (ctxt->error)
+        if (ctxt->error) {
+            xsltTransformError(NULL, NULL, NULL,
+                    "xsltCompileIdKeyPattern : Literal expected\n");
+            xmlFree(lit);
             return;
+        }
         SKIP_BLANKS;
         if (CUR != ')') {
             xsltTransformError(NULL, NULL, NULL,
                     "xsltCompileIdKeyPattern : ) expected\n");
+            xmlFree(lit);
+            xmlFree(lit2);
             ctxt->error = 1;
             return;
         }
         NEXT;
         /* URGENT TODO: support namespace in keys */
         PUSH(XSLT_OP_KEY, lit, lit2, novar);
+        lit = NULL;
+        lit2 = NULL;
     } else if (xmlStrEqual(name, (const xmlChar *)"processing-instruction")) {
         NEXT;
         SKIP_BLANKS;
         if (CUR != ')') {
             lit = xsltScanLiteral(ctxt);
-            if (ctxt->error)
+            if (ctxt->error) {
+                xsltTransformError(NULL, NULL, NULL,
+                        "xsltCompileIdKeyPattern : Literal expected\n");
                 return;
+            }
             SKIP_BLANKS;
             if (CUR != ')') {
                 xsltTransformError(NULL, NULL, NULL,
                         "xsltCompileIdKeyPattern : ) expected\n");
                 ctxt->error = 1;
                 return;
             }
         }
         NEXT;
         PUSH(XSLT_OP_PI, lit, NULL, novar);
+        lit = NULL;
     } else if (xmlStrEqual(name, (const xmlChar *)"text")) {
         NEXT;
         SKIP_BLANKS;
         if (CUR != ')') {
             xsltTransformError(NULL, NULL, NULL,
                     "xsltCompileIdKeyPattern : ) expected\n");
             ctxt->error = 1;
             return;
         }
         NEXT;
@@ skipping 30 matching lines @@
             "xsltCompileIdKeyPattern : expecting 'key' or 'id' or node type\n");
         ctxt->error = 1;
         return;
     } else {
         xsltTransformError(NULL, NULL, NULL,
             "xsltCompileIdKeyPattern : node type\n");
         ctxt->error = 1;
         return;
     }
 error:
-    if (name != NULL)
-        xmlFree(name);
+    return;
 }
 
 /**
  * xsltCompileStepPattern:
  * @ctxt:  the compilation context
  * @token:  a posible precompiled name
  * @novar: flag to prohibit xslt variables from pattern
  *
  * Compile the XSLT StepPattern and generates a precompiled
  * form suitable for fast matching.
  *
- * [5] StepPattern ::= ChildOrAttributeAxisSpecifier NodeTest Predicate* 
+ * [5] StepPattern ::= ChildOrAttributeAxisSpecifier NodeTest Predicate*
  * [6] ChildOrAttributeAxisSpecifier ::= AbbreviatedAxisSpecifier
  *                                     | ('child' | 'attribute') '::'
  * from XPath
  * [7]  NodeTest ::= NameTest
  *                 | NodeType '(' ')'
  *                 | 'processing-instruction' '(' Literal ')'
  * [8] Predicate ::= '[' PredicateExpr ']'
  * [9] PredicateExpr ::= Expr
  * [13] AbbreviatedAxisSpecifier ::= '@'?
  * [37] NameTest ::= '*' | NCName ':' '*' | QName
@@ skipping 30 matching lines @@
                     "xsltCompileStepPattern : Name expected\n");
             ctxt->error = 1;
             goto error;
         }
     }
 
 
     SKIP_BLANKS;
     if (CUR == '(') {
         xsltCompileIdKeyPattern(ctxt, token, 0, novar, axis);
+        xmlFree(token);
+        token = NULL;
         if (ctxt->error)
             goto error;
     } else if (CUR == ':') {
         NEXT;
         if (CUR != ':') {
             xmlChar *prefix = token;
             xmlNsPtr ns;
 
             /*
              * This is a namespace match
              */
             token = xsltScanNCName(ctxt);
             ns = xmlSearchNs(ctxt->doc, ctxt->elem, prefix);
             if (ns == NULL) {
                 xsltTransformError(NULL, NULL, NULL,
             "xsltCompileStepPattern : no namespace bound to prefix %s\n",
                                  prefix);
                 xmlFree(prefix);
+                prefix=NULL;
                 ctxt->error = 1;
                 goto error;
             } else {
                 URL = xmlStrdup(ns->href);
             }
             xmlFree(prefix);
+            prefix=NULL;
             if (token == NULL) {
                 if (CUR == '*') {
                     NEXT;
                     if (axis == AXIS_ATTRIBUTE) {
                         PUSH(XSLT_OP_ATTR, NULL, URL, novar);
+                        URL = NULL;
                     }
                     else {
                         PUSH(XSLT_OP_NS, URL, NULL, novar);
+                        URL = NULL;
                     }
                 } else {
                     xsltTransformError(NULL, NULL, NULL,
                             "xsltCompileStepPattern : Name expected\n");
                     ctxt->error = 1;
                     goto error;
                 }
             } else {
                 if (axis == AXIS_ATTRIBUTE) {
                     PUSH(XSLT_OP_ATTR, token, URL, novar);
+                    token = NULL;
+                    URL = NULL;
                 }
                 else {
                     PUSH(XSLT_OP_ELEM, token, URL, novar);
+                    token = NULL;
+                    URL = NULL;
                 }
             }
         } else {
             if (axis != 0) {
                 xsltTransformError(NULL, NULL, NULL,
                     "xsltCompileStepPattern : NodeTest expected\n");
                 ctxt->error = 1;
                 goto error;
             }
             NEXT;
             if (xmlStrEqual(token, (const xmlChar *) "child")) {
                 axis = AXIS_CHILD;
             } else if (xmlStrEqual(token, (const xmlChar *) "attribute")) {
                 axis = AXIS_ATTRIBUTE;
             } else {
                 xsltTransformError(NULL, NULL, NULL,
                     "xsltCompileStepPattern : 'child' or 'attribute' expected\n");
                 ctxt->error = 1;
                 goto error;
             }
             xmlFree(token);
+            token = NULL;
             SKIP_BLANKS;
             token = xsltScanNCName(ctxt);
             goto parse_node_test;
         }
     } else {
         URI = xsltGetQNameURI(ctxt->elem, &token);
         if (token == NULL) {
             ctxt->error = 1;
             goto error;
         }
         if (URI != NULL)
             URL = xmlStrdup(URI);
         if (axis == AXIS_ATTRIBUTE) {
             PUSH(XSLT_OP_ATTR, token, URL, novar);
+            token = NULL;
+            URL = NULL;
         }
         else {
             PUSH(XSLT_OP_ELEM, token, URL, novar);
+            token = NULL;
+            URL = NULL;
         }
     }
 parse_predicate:
     SKIP_BLANKS;
     level = 0;
     while (CUR == '[') {
         const xmlChar *q;
         xmlChar *ret = NULL;
 
         level++;
@@ skipping 19 matching lines @@
             NEXT;
         }
         if (CUR == 0) {
             xsltTransformError(NULL, NULL, NULL,
                     "xsltCompileStepPattern : ']' expected\n");
             ctxt->error = 1;
             return;
         }
         ret = xmlStrndup(q, CUR_PTR - q);
         PUSH(XSLT_OP_PREDICATE, ret, NULL, novar);
+        ret = NULL;
         /* push the predicate lower than local test */
         SWAP();
         NEXT;
         SKIP_BLANKS;
     }
     return;
 error:
     if (token != NULL)
         xmlFree(token);
     if (name != NULL)
@@ skipping 88 matching lines @@
         name = xsltScanNCName(ctxt);
         if (name == NULL) {
             xsltTransformError(NULL, NULL, NULL,
                     "xsltCompileLocationPathPattern : Name expected\n");
             ctxt->error = 1;
             return;
         }
         SKIP_BLANKS;
         if ((CUR == '(') && !xmlXPathIsNodeType(name)) {
             xsltCompileIdKeyPattern(ctxt, name, 1, novar, 0);
-            if (ctxt->error)
-                return;
+            xmlFree(name);
+            name = NULL;
             if ((CUR == '/') && (NXT(1) == '/')) {
                 PUSH(XSLT_OP_ANCESTOR, NULL, NULL, novar);
                 NEXT;
                 NEXT;
                 SKIP_BLANKS;
                 xsltCompileRelativePathPattern(ctxt, NULL, novar);
             } else if (CUR == '/') {
                 PUSH(XSLT_OP_PARENT, NULL, NULL, novar);
                 NEXT;
                 SKIP_BLANKS;
@@ skipping 57 matching lines @@
                 level--;
             else if (pattern[end] == '\'') {
                 end++;
                 while ((pattern[end] != 0) && (pattern[end] != '\''))
                     end++;
             } else if (pattern[end] == '"') {
                 end++;
                 while ((pattern[end] != 0) && (pattern[end] != '"'))
                     end++;
             }
-      if (pattern[end] == 0)
-          break;
+            if (pattern[end] == 0)
+                break;
             end++;
         }
         if (current == end) {
             xsltTransformError(NULL, NULL, node,
                              "xsltCompilePattern : NULL pattern\n");
             goto error;
         }
         element = xsltNewCompMatch();
         if (element == NULL) {
             goto error;
@@ skipping 156 matching lines @@
     const xmlChar *name = NULL;
     float priority;              /* the priority */
 
     if ((style == NULL) || (cur == NULL) || (cur->match == NULL))
         return(-1);
 
     priority = cur->priority;
     pat = xsltCompilePatternInternal(cur->match, style->doc, cur->elem,
                     style, NULL, 1);
     if (pat == NULL)
-        return(-1);
+        return(-1);
     while (pat) {
         next = pat->next;
         pat->next = NULL;
         name = NULL;
-        
+
         pat->template = cur;
         if (mode != NULL)
             pat->mode = xmlDictLookup(style->dict, mode, -1);
         if (modeURI != NULL)
             pat->modeURI = xmlDictLookup(style->dict, modeURI, -1);
         if (priority != XSLT_PAT_NO_PRIORITY)
             pat->priority = priority;
 
         /*
          * insert it in the hash table list corresponding to its lookup name
@@ skipping 366 matching lines @@
         {
             /*
             * Compute all remaining keys for this document.
             *
             * REVISIT TODO: I think this could be further optimized.
             */
             if (xsltComputeAllKeys(ctxt, node) == -1)
                 goto error;
 
             switch (node->type) {
-                case XML_ELEMENT_NODE:              
+                case XML_ELEMENT_NODE:
                     if (node->psvi != NULL) keyed = 1;
                     break;
                 case XML_ATTRIBUTE_NODE:
                     if (((xmlAttrPtr) node)->psvi != NULL) keyed = 1;
                     break;
                 case XML_TEXT_NODE:
                 case XML_CDATA_SECTION_NODE:
                 case XML_COMMENT_NODE:
-                case XML_PI_NODE:               
+                case XML_PI_NODE:
                     if (node->psvi != NULL) keyed = 1;
                     break;
                 case XML_DOCUMENT_NODE:
                 case XML_HTML_DOCUMENT_NODE:
                     if (((xmlDocPtr) node)->psvi != NULL) keyed = 1;
-                    break;              
+                    break;
                 default:
                     break;
             }
             if (keyed)
                 goto keyed_match;
         }
         if (ret != NULL)
             return(ret);
 
         /*
@@ skipping 39 matching lines @@
     if (style->parentMatch != NULL)
         xsltFreeCompMatchList(style->parentMatch);
     if (style->textMatch != NULL)
         xsltFreeCompMatchList(style->textMatch);
     if (style->piMatch != NULL)
         xsltFreeCompMatchList(style->piMatch);
     if (style->commentMatch != NULL)
         xsltFreeCompMatchList(style->commentMatch);
 }