Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 103 insertions, 103 deletions

diff --git a/contrib/libs/libxml/xpointer.c b/contrib/libs/libxml/xpointer.c
index 587a2071acb..c1732a584a6 100644
--- a/contrib/libs/libxml/xpointer.c
+++ b/contrib/libs/libxml/xpointer.c
@@ -14,11 +14,11 @@
  * [email protected]
  */
 
-/* To avoid EBCDIC trouble when parsing on zOS */ 
-#if defined(__MVS__) 
-#pragma convert("ISO8859-1") 
-#endif 
- 
+/* To avoid EBCDIC trouble when parsing on zOS */
+#if defined(__MVS__)
+#pragma convert("ISO8859-1")
+#endif
+
 #define IN_LIBXML
 #include "libxml.h"
 
@@ -27,7 +27,7 @@
  *       be parsed beforehand instead of a progressive evaluation
  * TODO: Access into entities references are not supported now ...
  *       need a start to be able to pop out of entities refs since
- *       parent is the entity declaration, not the ref. 
+ *       parent is the entity declaration, not the ref.
  */
 
 #include <string.h>
@@ -90,7 +90,7 @@ xmlXPtrErrMemory(const char *extra)
  *
  * Handle a redefinition of attribute error
  */
-static void LIBXML_ATTR_FORMAT(3,0) 
+static void LIBXML_ATTR_FORMAT(3,0)
 xmlXPtrErr(xmlXPathParserContextPtr ctxt, int error,
            const char * msg, const xmlChar *extra)
 {
@@ -104,10 +104,10 @@ xmlXPtrErr(xmlXPathParserContextPtr ctxt, int error,
 			msg, extra);
 	return;
     }
- 
-    /* cleanup current last error */ 
-    xmlResetError(&ctxt->context->lastError); 
- 
+
+    /* cleanup current last error */
+    xmlResetError(&ctxt->context->lastError);
+
     ctxt->context->lastError.domain = XML_FROM_XPOINTER;
     ctxt->context->lastError.code = error;
     ctxt->context->lastError.level = XML_ERR_ERROR;
@@ -329,45 +329,45 @@ xmlXPtrRangesEqual(xmlXPathObjectPtr range1, xmlXPathObjectPtr range2) {
 }
 
 /**
- * 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); 
-} 
- 
-/** 
+ * 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
@@ -392,7 +392,7 @@ xmlXPtrNewRange(xmlNodePtr start, int startindex,
     if (endindex < 0)
 	return(NULL);
 
-    ret = xmlXPtrNewRangeInternal(start, startindex, end, endindex); 
+    ret = xmlXPtrNewRangeInternal(start, startindex, end, endindex);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
@@ -419,8 +419,8 @@ xmlXPtrNewRangePoints(xmlXPathObjectPtr start, xmlXPathObjectPtr end) {
     if (end->type != XPATH_POINT)
 	return(NULL);
 
-    ret = xmlXPtrNewRangeInternal(start->user, start->index, end->user, 
-                                  end->index); 
+    ret = xmlXPtrNewRangeInternal(start->user, start->index, end->user,
+                                  end->index);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
@@ -445,7 +445,7 @@ xmlXPtrNewRangePointNode(xmlXPathObjectPtr start, xmlNodePtr end) {
     if (start->type != XPATH_POINT)
 	return(NULL);
 
-    ret = xmlXPtrNewRangeInternal(start->user, start->index, end, -1); 
+    ret = xmlXPtrNewRangeInternal(start->user, start->index, end, -1);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
@@ -470,7 +470,7 @@ xmlXPtrNewRangeNodePoint(xmlNodePtr start, xmlXPathObjectPtr end) {
     if (end->type != XPATH_POINT)
 	return(NULL);
 
-    ret = xmlXPtrNewRangeInternal(start, -1, end->user, end->index); 
+    ret = xmlXPtrNewRangeInternal(start, -1, end->user, end->index);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
@@ -493,7 +493,7 @@ xmlXPtrNewRangeNodes(xmlNodePtr start, xmlNodePtr end) {
     if (end == NULL)
 	return(NULL);
 
-    ret = xmlXPtrNewRangeInternal(start, -1, end, -1); 
+    ret = xmlXPtrNewRangeInternal(start, -1, end, -1);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
@@ -513,7 +513,7 @@ xmlXPtrNewCollapsedRange(xmlNodePtr start) {
     if (start == NULL)
 	return(NULL);
 
-    ret = xmlXPtrNewRangeInternal(start, -1, NULL, -1); 
+    ret = xmlXPtrNewRangeInternal(start, -1, NULL, -1);
     return(ret);
 }
 
@@ -528,8 +528,8 @@ xmlXPtrNewCollapsedRange(xmlNodePtr start) {
  */
 xmlXPathObjectPtr
 xmlXPtrNewRangeNodeObject(xmlNodePtr start, xmlXPathObjectPtr end) {
-    xmlNodePtr endNode; 
-    int endIndex; 
+    xmlNodePtr endNode;
+    int endIndex;
     xmlXPathObjectPtr ret;
 
     if (start == NULL)
@@ -538,28 +538,28 @@ xmlXPtrNewRangeNodeObject(xmlNodePtr start, xmlXPathObjectPtr end) {
 	return(NULL);
     switch (end->type) {
 	case XPATH_POINT:
-	    endNode = end->user; 
-	    endIndex = end->index; 
-	    break; 
+	    endNode = end->user;
+	    endIndex = end->index;
+	    break;
 	case XPATH_RANGE:
-	    endNode = end->user2; 
-	    endIndex = end->index2; 
+	    endNode = end->user2;
+	    endIndex = end->index2;
 	    break;
 	case XPATH_NODESET:
 	    /*
 	     * Empty set ...
 	     */
-	    if ((end->nodesetval == NULL) || (end->nodesetval->nodeNr <= 0)) 
+	    if ((end->nodesetval == NULL) || (end->nodesetval->nodeNr <= 0))
 		return(NULL);
-	    endNode = end->nodesetval->nodeTab[end->nodesetval->nodeNr - 1]; 
-	    endIndex = -1; 
+	    endNode = end->nodesetval->nodeTab[end->nodesetval->nodeNr - 1];
+	    endIndex = -1;
 	    break;
 	default:
 	    /* TODO */
 	    return(NULL);
     }
 
-    ret = xmlXPtrNewRangeInternal(start, -1, endNode, endIndex); 
+    ret = xmlXPtrNewRangeInternal(start, -1, endNode, endIndex);
     xmlXPtrRangeCheckOrder(ret);
     return(ret);
 }
@@ -956,10 +956,10 @@ xmlXPtrEvalXPtrPart(xmlXPathParserContextPtr ctxt, xmlChar *name) {
     if (name == NULL)
 	XP_ERROR(XPATH_EXPR_ERROR);
 
-    if (CUR != '(') { 
-        xmlFree(name); 
+    if (CUR != '(') {
+        xmlFree(name);
 	XP_ERROR(XPATH_EXPR_ERROR);
-    } 
+    }
     NEXT;
     level = 1;
 
@@ -968,7 +968,7 @@ xmlXPtrEvalXPtrPart(xmlXPathParserContextPtr ctxt, xmlChar *name) {
     buffer = (xmlChar *) xmlMallocAtomic(len * sizeof (xmlChar));
     if (buffer == NULL) {
         xmlXPtrErrMemory("allocating buffer");
-        xmlFree(name); 
+        xmlFree(name);
 	return;
     }
 
@@ -993,7 +993,7 @@ xmlXPtrEvalXPtrPart(xmlXPathParserContextPtr ctxt, xmlChar *name) {
     *cur = 0;
 
     if ((level != 0) && (CUR == 0)) {
-        xmlFree(name); 
+        xmlFree(name);
 	xmlFree(buffer);
 	XP_ERROR(XPTR_SYNTAX_ERROR);
     }
@@ -1026,7 +1026,7 @@ xmlXPtrEvalXPtrPart(xmlXPathParserContextPtr ctxt, xmlChar *name) {
 	    if (name2 == NULL) {
 		CUR_PTR = left;
 		xmlFree(buffer);
-                xmlFree(name); 
+                xmlFree(name);
 		XP_ERROR(XPATH_EXPR_ERROR);
 	    }
 	    xmlXPtrEvalChildSeq(ctxt, name2);
@@ -1186,7 +1186,7 @@ xmlXPtrEvalFullXPtr(xmlXPathParserContextPtr ctxt, xmlChar *name) {
 static void
 xmlXPtrEvalChildSeq(xmlXPathParserContextPtr ctxt, xmlChar *name) {
     /*
-     * XPointer don't allow by syntax to address in multirooted trees 
+     * XPointer don't allow by syntax to address in multirooted trees
      * this might prove useful in some cases, warn about it.
      */
     if ((name == NULL) && (CUR == '/') && (NXT(1) != '1')) {
@@ -1202,23 +1202,23 @@ xmlXPtrEvalChildSeq(xmlXPathParserContextPtr ctxt, xmlChar *name) {
     }
 
     while (CUR == '/') {
-	int child = 0, overflow = 0; 
+	int child = 0, overflow = 0;
 	NEXT;
 
 	while ((CUR >= '0') && (CUR <= '9')) {
-            int d = CUR - '0'; 
-            if (child > INT_MAX / 10) 
-                overflow = 1; 
-            else 
-                child *= 10; 
-            if (child > INT_MAX - d) 
-                overflow = 1; 
-            else 
-                child += d; 
+            int d = CUR - '0';
+            if (child > INT_MAX / 10)
+                overflow = 1;
+            else
+                child *= 10;
+            if (child > INT_MAX - d)
+                overflow = 1;
+            else
+                child += d;
 	    NEXT;
 	}
-        if (overflow) 
-            child = 0; 
+        if (overflow)
+            child = 0;
 	xmlXPtrGetChildNo(ctxt, child);
     }
 }
@@ -1383,7 +1383,7 @@ xmlXPtrEval(const xmlChar *str, xmlXPathContextPtr ctx) {
 		     */
 		    xmlNodeSetPtr set;
 		    set = tmp->nodesetval;
-		    if ((set == NULL) || (set->nodeNr != 1) || 
+		    if ((set == NULL) || (set->nodeNr != 1) ||
 			(set->nodeTab[0] != (xmlNodePtr) ctx->doc))
 			stack++;
 		} else
@@ -1818,8 +1818,8 @@ xmlXPtrStartPointFunction(xmlXPathParserContextPtr ctxt, int nargs) {
 		case XPATH_RANGE: {
 		    xmlNodePtr node = tmp->user;
 		    if (node != NULL) {
-			if ((node->type == XML_ATTRIBUTE_NODE) || 
-                            (node->type == XML_NAMESPACE_DECL)) { 
+			if ((node->type == XML_ATTRIBUTE_NODE) ||
+                            (node->type == XML_NAMESPACE_DECL)) {
 			    xmlXPathFreeObject(obj);
 			    xmlXPtrFreeLocationSet(newset);
 			    XP_ERROR(XPTR_SYNTAX_ERROR);
@@ -1914,8 +1914,8 @@ xmlXPtrEndPointFunction(xmlXPathParserContextPtr ctxt, int nargs) {
 		case XPATH_RANGE: {
 		    xmlNodePtr node = tmp->user2;
 		    if (node != NULL) {
-			if ((node->type == XML_ATTRIBUTE_NODE) || 
-                            (node->type == XML_NAMESPACE_DECL)) { 
+			if ((node->type == XML_ATTRIBUTE_NODE) ||
+                            (node->type == XML_NAMESPACE_DECL)) {
 			    xmlXPathFreeObject(obj);
 			    xmlXPtrFreeLocationSet(newset);
 			    XP_ERROR(XPTR_SYNTAX_ERROR);
@@ -2056,11 +2056,11 @@ xmlXPtrRangeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
 	xmlXPathFreeObject(set);
         XP_ERROR(XPATH_MEMORY_ERROR);
     }
-    if (oldset != NULL) { 
-        for (i = 0;i < oldset->locNr;i++) { 
-            xmlXPtrLocationSetAdd(newset, 
-                    xmlXPtrCoveringRange(ctxt, oldset->locTab[i])); 
-        } 
+    if (oldset != NULL) {
+        for (i = 0;i < oldset->locNr;i++) {
+            xmlXPtrLocationSetAdd(newset,
+                    xmlXPtrCoveringRange(ctxt, oldset->locTab[i]));
+        }
     }
 
     /*
@@ -2228,14 +2228,14 @@ xmlXPtrRangeInsideFunction(xmlXPathParserContextPtr ctxt, int nargs) {
  * @nargs:  the number of args
  *
  * Implement the range-to() XPointer function
- * 
- * Obsolete. range-to is not a real function but a special type of location 
- * step which is handled in xpath.c. 
+ *
+ * Obsolete. range-to is not a real function but a special type of location
+ * step which is handled in xpath.c.
  */
 void
-xmlXPtrRangeToFunction(xmlXPathParserContextPtr ctxt, 
-                       int nargs ATTRIBUTE_UNUSED) { 
-    XP_ERROR(XPATH_EXPR_ERROR); 
+xmlXPtrRangeToFunction(xmlXPathParserContextPtr ctxt,
+                       int nargs ATTRIBUTE_UNUSED) {
+    XP_ERROR(XPATH_EXPR_ERROR);
 }
 
 /**