Add a helper function for allocating XPointer ranges.

third_party/libxml/src/xpointer.c

 /*
  * xpointer.c : Code to handle XML Pointer
  *
  * Base implementation was made accordingly to
  * W3C Candidate Recommendation 7 June 2000
  * http://www.w3.org/TR/2000/CR-xptr-20000607
  *
  * Added support for the element() scheme described in:
  * W3C Proposed Recommendation 13 November 2002
  * http://www.w3.org/TR/2002/PR-xptr-element-20021113/
@@ skipping 302 matching lines @@
     if (range1->index != range2->index)
         return(0);
     if (range1->user2 != range2->user2)
         return(0);
     if (range1->index2 != range2->index2)
         return(0);
     return(1);
 }
 
 /**
+ * xmlXPtrNewRangeInternal:
+ * @start:  the starting node
+ * @startindex:  the start index
+ * @end:  the ending point
+ * @endindex:  the ending index
+ *
+ * Internal function to create a new xmlXPathObjectPtr of type range
+ *
+ * Returns the newly created object.
+ */
+static xmlXPathObjectPtr
+xmlXPtrNewRangeInternal(xmlNodePtr start, int startindex,
+                        xmlNodePtr end, int endindex) {
+    xmlXPathObjectPtr ret;
+
+    /*
+     * Namespace nodes must be copied (see xmlXPathNodeSetDupNs).
+     * Disallow them for now.
+     */
+    if ((start != NULL) && (start->type == XML_NAMESPACE_DECL))
+        return(NULL);
+    if ((end != NULL) && (end->type == XML_NAMESPACE_DECL))
+        return(NULL);
+
+    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+    if (ret == NULL) {
+        xmlXPtrErrMemory("allocating range");
+        return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlXPathObject));
+    ret->type = XPATH_RANGE;
+    ret->user = start;
+    ret->index = startindex;
+    ret->user2 = end;
+    ret->index2 = endindex;
+    return(ret);
+}
+
+/**
  * xmlXPtrNewRange:
  * @start:  the starting node
  * @startindex:  the start index
  * @end:  the ending point
  * @endindex:  the ending index
  *
  * Create a new xmlXPathObjectPtr of type range
  *
  * Returns the newly created object.
  */
 xmlXPathObjectPtr
 xmlXPtrNewRange(xmlNodePtr start, int startindex,
                 xmlNodePtr end, int endindex) {
     xmlXPathObjectPtr ret;
 
     if (start == NULL)
         return(NULL);
     if (end == NULL)
         return(NULL);
     if (startindex < 0)
         return(NULL);
     if (endindex < 0)
         return(NULL);
 
-    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
-    if (ret == NULL) {
-        xmlXPtrErrMemory("allocating range");
-        return(NULL);
-    }
-    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
-    ret->type = XPATH_RANGE;
-    ret->user = start;
-    ret->index = startindex;
-    ret->user2 = end;
-    ret->index2 = endindex;
+    ret = xmlXPtrNewRangeInternal(start, startindex, end, endindex);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
 
 /**
  * xmlXPtrNewRangePoints:
  * @start:  the starting point
  * @end:  the ending point
  *
  * Create a new xmlXPathObjectPtr of type range using 2 Points
  *
  * Returns the newly created object.
  */
 xmlXPathObjectPtr
 xmlXPtrNewRangePoints(xmlXPathObjectPtr start, xmlXPathObjectPtr end) {
     xmlXPathObjectPtr ret;
 
     if (start == NULL)
         return(NULL);
     if (end == NULL)
         return(NULL);
     if (start->type != XPATH_POINT)
         return(NULL);
     if (end->type != XPATH_POINT)
         return(NULL);
 
-    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
-    if (ret == NULL) {
-        xmlXPtrErrMemory("allocating range");
-        return(NULL);
-    }
-    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
-    ret->type = XPATH_RANGE;
-    ret->user = start->user;
-    ret->index = start->index;
-    ret->user2 = end->user;
-    ret->index2 = end->index;
+    ret = xmlXPtrNewRangeInternal(start->user, start->index, end->user,
+                                  end->index);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
 
 /**
  * xmlXPtrNewRangePointNode:
  * @start:  the starting point
  * @end:  the ending node
  *
  * Create a new xmlXPathObjectPtr of type range from a point to a node
  *
  * Returns the newly created object.
  */
 xmlXPathObjectPtr
 xmlXPtrNewRangePointNode(xmlXPathObjectPtr start, xmlNodePtr end) {
     xmlXPathObjectPtr ret;
 
     if (start == NULL)
         return(NULL);
     if (end == NULL)
         return(NULL);
     if (start->type != XPATH_POINT)
         return(NULL);
 
-    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
-    if (ret == NULL) {
-        xmlXPtrErrMemory("allocating range");
-        return(NULL);
-    }
-    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
-    ret->type = XPATH_RANGE;
-    ret->user = start->user;
-    ret->index = start->index;
-    ret->user2 = end;
-    ret->index2 = -1;
+    ret = xmlXPtrNewRangeInternal(start->user, start->index, end, -1);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
 
 /**
  * xmlXPtrNewRangeNodePoint:
  * @start:  the starting node
  * @end:  the ending point
  *
  * Create a new xmlXPathObjectPtr of type range from a node to a point
  *
  * Returns the newly created object.
  */
 xmlXPathObjectPtr
 xmlXPtrNewRangeNodePoint(xmlNodePtr start, xmlXPathObjectPtr end) {
     xmlXPathObjectPtr ret;
 
     if (start == NULL)
         return(NULL);
     if (end == NULL)
         return(NULL);
     if (start->type != XPATH_POINT)
         return(NULL);
     if (end->type != XPATH_POINT)
         return(NULL);
 
-    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
-    if (ret == NULL) {
-        xmlXPtrErrMemory("allocating range");
-        return(NULL);
-    }
-    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
-    ret->type = XPATH_RANGE;
-    ret->user = start;
-    ret->index = -1;
-    ret->user2 = end->user;
-    ret->index2 = end->index;
+    ret = xmlXPtrNewRangeInternal(start, -1, end->user, end->index);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
 
 /**
  * xmlXPtrNewRangeNodes:
  * @start:  the starting node
  * @end:  the ending node
  *
  * Create a new xmlXPathObjectPtr of type range using 2 nodes
  *
  * Returns the newly created object.
  */
 xmlXPathObjectPtr
 xmlXPtrNewRangeNodes(xmlNodePtr start, xmlNodePtr end) {
     xmlXPathObjectPtr ret;
 
     if (start == NULL)
         return(NULL);
     if (end == NULL)
         return(NULL);
 
-    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
-    if (ret == NULL) {
-        xmlXPtrErrMemory("allocating range");
-        return(NULL);
-    }
-    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
-    ret->type = XPATH_RANGE;
-    ret->user = start;
-    ret->index = -1;
-    ret->user2 = end;
-    ret->index2 = -1;
+    ret = xmlXPtrNewRangeInternal(start, -1, end, -1);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
 
 /**
  * xmlXPtrNewCollapsedRange:
  * @start:  the starting and ending node
  *
  * Create a new xmlXPathObjectPtr of type range using a single nodes
  *
  * Returns the newly created object.
  */
 xmlXPathObjectPtr
 xmlXPtrNewCollapsedRange(xmlNodePtr start) {
     xmlXPathObjectPtr ret;
 
     if (start == NULL)
         return(NULL);
 
-    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
-    if (ret == NULL) {
-        xmlXPtrErrMemory("allocating range");
-        return(NULL);
-    }
-    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
-    ret->type = XPATH_RANGE;
-    ret->user = start;
-    ret->index = -1;
-    ret->user2 = NULL;
-    ret->index2 = -1;
+    ret = xmlXPtrNewRangeInternal(start, -1, NULL, -1);
     return(ret);
 }
 
 /**
  * xmlXPtrNewRangeNodeObject:
  * @start:  the starting node
  * @end:  the ending object
  *
  * Create a new xmlXPathObjectPtr of type range from a not to an object
  *
  * Returns the newly created object.
  */
 xmlXPathObjectPtr
 xmlXPtrNewRangeNodeObject(xmlNodePtr start, xmlXPathObjectPtr end) {
+    xmlNodePtr endNode;
+    int endIndex;
     xmlXPathObjectPtr ret;
 
     if (start == NULL)
         return(NULL);
     if (end == NULL)
         return(NULL);
     switch (end->type) {
         case XPATH_POINT:
+            endNode = end->user;
+            endIndex = end->index;
+            break;
         case XPATH_RANGE:
+            endNode = end->user2;
+            endIndex = end->index2;
             break;
         case XPATH_NODESET:
             /*
              * Empty set ...
              */
             if (end->nodesetval->nodeNr <= 0)
                 return(NULL);
+            endNode = end->nodesetval->nodeTab[end->nodesetval->nodeNr - 1];
+            endIndex = -1;
             break;
         default:
             /* TODO */
             return(NULL);
     }
 
-    ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
-    if (ret == NULL) {
-        xmlXPtrErrMemory("allocating range");
-        return(NULL);
-    }
-    memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
-    ret->type = XPATH_RANGE;
-    ret->user = start;
-    ret->index = -1;
-    switch (end->type) {
-        case XPATH_POINT:
-            ret->user2 = end->user;
-            ret->index2 = end->index;
-            break;
-        case XPATH_RANGE:
-            ret->user2 = end->user2;
-            ret->index2 = end->index2;
-            break;
-        case XPATH_NODESET: {
-            ret->user2 = end->nodesetval->nodeTab[end->nodesetval->nodeNr - 1];
-            ret->index2 = -1;
-            break;
-        }
-        default:
-            STRANGE
-            return(NULL);
-    }
+    ret = xmlXPtrNewRangeInternal(start, -1, endNode, endIndex);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
 
 #define XML_RANGESET_DEFAULT    10
 
 /**
  * xmlXPtrLocationSetCreate:
  * @val:  an initial xmlXPathObjectPtr, or NULL
  *
@@ skipping 2355 matching lines @@
     }
 
     NEXT;
     SKIP_BLANKS;
 }
 
 #define bottom_xpointer
 #include "elfgcchack.h"
 #endif