diff --git a/c14n.c b/c14n.c
index 2b27020..7aab539 100644
--- a/c14n.c
+++ b/c14n.c
@@ -19,7 +19,7 @@
 
 #include <libxml/tree.h>
 #include <libxml/parser.h>
-#include <libxml/uri.h> 
+#include <libxml/uri.h>
 #include <libxml/xmlerror.h>
 #include <libxml/globals.h>
 #include <libxml/xpathInternals.h>
@@ -31,52 +31,50 @@
  *									*
  ************************************************************************/
 
-typedef enum {    
-    XMLC14N_BEFORE_DOCUMENT_ELEMENT=	0,
-    XMLC14N_INSIDE_DOCUMENT_ELEMENT=	1,
-    XMLC14N_AFTER_DOCUMENT_ELEMENT=	2    
+typedef enum {
+    XMLC14N_BEFORE_DOCUMENT_ELEMENT = 0,
+    XMLC14N_INSIDE_DOCUMENT_ELEMENT = 1,
+    XMLC14N_AFTER_DOCUMENT_ELEMENT = 2
 } xmlC14NPosition;
 
 typedef struct _xmlC14NCtx {
     /* input parameters */
-    xmlDocPtr		doc;
-    xmlNodeSetPtr	visible_nodes;
-    int			with_comments;
-    xmlOutputBufferPtr	buf;
+    xmlDocPtr doc;
+    xmlNodeSetPtr visible_nodes;
+    int with_comments;
+    xmlOutputBufferPtr buf;
 
     /* position in the XML document */
-    xmlC14NPosition	pos;
-    int			parent_is_doc;
+    xmlC14NPosition pos;
+    int parent_is_doc;
 
     /* exclusive canonicalization */
-    int			exclusive;
-    xmlNodeSetPtr	ns_rendered;
-    xmlChar		**inclusive_ns_prefixes;
+    int exclusive;
+    xmlNodeSetPtr ns_rendered;
+    xmlChar **inclusive_ns_prefixes;
 } xmlC14NCtx, *xmlC14NCtxPtr;
 
 
-static int	xmlC14NProcessNode	(xmlC14NCtxPtr ctx, 
-					 xmlNodePtr cur);
-static int	xmlC14NProcessNodeList	(xmlC14NCtxPtr ctx,
-					 xmlNodePtr cur);
+static int xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur);
+static int xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur);
 typedef enum {
-    XMLC14N_NORMALIZE_ATTR=		0,
-    XMLC14N_NORMALIZE_COMMENT=		1,
-    XMLC14N_NORMALIZE_PI=		2,
-    XMLC14N_NORMALIZE_TEXT=		3
-} xmlC14NNormalizationMode;    
+    XMLC14N_NORMALIZE_ATTR = 0,
+    XMLC14N_NORMALIZE_COMMENT = 1,
+    XMLC14N_NORMALIZE_PI = 2,
+    XMLC14N_NORMALIZE_TEXT = 3
+} xmlC14NNormalizationMode;
 
-static xmlChar* xmlC11NNormalizeString	(const xmlChar *input,
-					 xmlC14NNormalizationMode mode);
+static xmlChar *xmlC11NNormalizeString(const xmlChar * input,
+                                       xmlC14NNormalizationMode mode);
 
 #define 	xmlC11NNormalizeAttr( a ) \
-    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_ATTR) 
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_ATTR)
 #define 	xmlC11NNormalizeComment( a ) \
-    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_COMMENT) 
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_COMMENT)
 #define 	xmlC11NNormalizePI( a )	\
-    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_PI) 
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_PI)
 #define 	xmlC11NNormalizeText( a ) \
-    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_TEXT) 
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_TEXT)
 
 /************************************************************************
  *									*
@@ -94,19 +92,22 @@
  *
  * Returns 1 if the node is visible or 0 otherwise.  
  */
+
 /* todo: make it a define? */
-static int 
-xmlC14NIsVisible(xmlC14NCtxPtr ctx, void *node) {
+static int
+xmlC14NIsVisible(xmlC14NCtxPtr ctx, void *node)
+{
     /* 
      * If the input is an XPath node-set, then the node-set must explicitly 
      * contain every node to be rendered to the canonical form.
      */
-    if(ctx->visible_nodes != NULL && 
-	    !xmlXPathNodeSetContains(ctx->visible_nodes, (xmlNodePtr)node)) {
-	return(0);
-    }     
+    if ((ctx->visible_nodes != NULL) &&
+        (!xmlXPathNodeSetContains(ctx->visible_nodes, (xmlNodePtr) node)))
+    {
+        return (0);
+    }
 
-    return(1);
+    return (1);
 }
 
 /**
@@ -118,12 +119,16 @@
  *
  * Returns 1 if the node is default or 0 otherwise
  */
+
 /* todo: make it a define? */
 static int
-xmlC14NIsXmlNs(xmlNsPtr ns) {
-    return (ns != NULL && 
-	    xmlStrEqual(ns->prefix, BAD_CAST "xml") && 
-	    xmlStrEqual(ns->href, BAD_CAST "http://www.w3.org/XML/1998/namespace")); 
+xmlC14NIsXmlNs(xmlNsPtr ns)
+{
+    return ((ns != NULL) &&
+            (xmlStrEqual(ns->prefix, BAD_CAST "xml")) &&
+            (xmlStrEqual(ns->href,
+                         BAD_CAST
+                         "http://www.w3.org/XML/1998/namespace")));
 }
 
 /**
@@ -136,26 +141,28 @@
  * Returns 1 if we already wrote this namespace or 0 otherwise
  */
 static int
-xmlExcC14NIsRendered(xmlC14NCtxPtr ctx, xmlNsPtr ns) {
+xmlExcC14NIsRendered(xmlC14NCtxPtr ctx, xmlNsPtr ns)
+{
     int i;
-    
-    if(ctx == NULL || ctx->ns_rendered == NULL || ns == NULL) {
-	return(0);
+
+    if ((ctx == NULL) || (ctx->ns_rendered == NULL) || (ns == NULL)) {
+        return (0);
     }
 
-    if(ctx->ns_rendered->nodeTab != NULL) {
-        for(i = ctx->ns_rendered->nodeNr - 1; i >= 0; --i) {
-	    xmlNsPtr ns1 = (xmlNsPtr)ctx->ns_rendered->nodeTab[i];
-	    if(xmlStrEqual(ns1->prefix, ns->prefix)) {
-		return (xmlStrEqual(ns1->href, ns->href));
-	    }
-	}
-    }   
+    if (ctx->ns_rendered->nodeTab != NULL) {
+        for (i = ctx->ns_rendered->nodeNr - 1; i >= 0; --i) {
+            xmlNsPtr ns1 = (xmlNsPtr) ctx->ns_rendered->nodeTab[i];
+
+            if (xmlStrEqual(ns1->prefix, ns->prefix)) {
+                return (xmlStrEqual(ns1->href, ns->href));
+            }
+        }
+    }
     /*
      * if the default namespace xmlns="" is not defined yet then 
      * we do not want to print it out
      */
-    return(xmlStrlen(ns->prefix) == 0 && xmlStrlen(ns->href) == 0); 
+    return ((xmlStrlen(ns->prefix) == 0) && (xmlStrlen(ns->href) == 0));
 }
 
 /**
@@ -167,13 +174,17 @@
  *
  * Returns -1 if ns1 < ns2, 0 if ns1 == ns2 or 1 if ns1 > ns2.
  */
-static int 
-xmlC14NNamespacesCompare(xmlNsPtr ns1, xmlNsPtr ns2) {
-    if(ns1 == ns2) return(0);
-    if(ns1 == NULL) return(-1);
-    if(ns2 == NULL) return(1);
-    
-    return(xmlStrcmp(ns1->prefix, ns2->prefix));
+static int
+xmlC14NNamespacesCompare(xmlNsPtr ns1, xmlNsPtr ns2)
+{
+    if (ns1 == ns2)
+        return (0);
+    if (ns1 == NULL)
+        return (-1);
+    if (ns2 == NULL)
+        return (1);
+
+    return (xmlStrcmp(ns1->prefix, ns2->prefix));
 }
 
 
@@ -187,26 +198,27 @@
  * Returns 1 on success or 0 on fail.
  */
 static int
-xmlC14NPrintNamespaces(const xmlNsPtr ns, xmlC14NCtxPtr ctx) {
+xmlC14NPrintNamespaces(const xmlNsPtr ns, xmlC14NCtxPtr ctx)
+{
 
-    if(ns == NULL || ctx == NULL) {
+    if ((ns == NULL) || (ctx == NULL)) {
 #ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NPrintNamespace: namespace or context pointer is null\n");
+                        "xmlC14NPrintNamespace: namespace or context pointer is null\n");
 #endif
-	return 0;
+        return 0;
     }
 
-    if(ns->prefix != NULL) {
-	xmlOutputBufferWriteString(ctx->buf, " xmlns:");
-	xmlOutputBufferWriteString(ctx->buf, (const char *)ns->prefix);
-	xmlOutputBufferWriteString(ctx->buf, "=\"");
+    if (ns->prefix != NULL) {
+        xmlOutputBufferWriteString(ctx->buf, " xmlns:");
+        xmlOutputBufferWriteString(ctx->buf, (const char *) ns->prefix);
+        xmlOutputBufferWriteString(ctx->buf, "=\"");
     } else {
-	xmlOutputBufferWriteString(ctx->buf, " xmlns=\"");
+        xmlOutputBufferWriteString(ctx->buf, " xmlns=\"");
     }
     xmlOutputBufferWriteString(ctx->buf, (const char *) ns->href);
     xmlOutputBufferWriteString(ctx->buf, "\"");
-    return(1);
+    return (1);
 }
 
 /**
@@ -249,36 +261,39 @@
  * Returns 0 on success or -1 on fail.
  */
 static int
-xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
+xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
     xmlNsPtr ns;
     xmlListPtr list;
     xmlNodePtr visible_parent;
     xmlNsPtr prev;
-        
-    if(ctx == NULL || cur == NULL || cur->type != XML_ELEMENT_NODE) {
-#ifdef DEBUG_C14N    
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NProcessNamespacesAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
-#endif	
-        return(-1);
-    }    
+                        "xmlC14NProcessNamespacesAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
+#endif
+        return (-1);
+    }
 
     /*
      * Create a sorted list to store element namespaces
      */
-    list = xmlListCreate(NULL, (xmlListDataCompare)xmlC14NNamespacesCompare);
-    if(list == NULL) {
+    list =
+        xmlListCreate(NULL, (xmlListDataCompare) xmlC14NNamespacesCompare);
+    if (list == NULL) {
 #ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NProcessNamespacesAxis: list creation failed\n");
+                        "xmlC14NProcessNamespacesAxis: list creation failed\n");
 #endif
-	return(-1);
-    }    
-    
+        return (-1);
+    }
+
     /* find nearest visible parent */
     visible_parent = cur->parent;
-    while(visible_parent != NULL && !xmlC14NIsVisible(ctx, visible_parent)) {
-	visible_parent = visible_parent->parent;  
+    while ((visible_parent != NULL) &&
+           (!xmlC14NIsVisible(ctx, visible_parent))) {
+        visible_parent = visible_parent->parent;
     }
 
     /* 
@@ -287,46 +302,49 @@
      * defined in node parents). By this we need to now walk thru 
      * all namespace in current node and all invisible ancesstors
      */
-     while(cur != visible_parent) {
-        for(ns = cur->nsDef; ns != NULL; ns = ns->next) { 
-    	    /* 
-	     * first of all ignore default "xml" namespace and 
-	     * already included namespace
-	     */
-	    if(xmlC14NIsXmlNs(ns) || xmlListSearch(list, ns) != NULL) {
-	        continue;
-	    } 
+    while (cur != visible_parent) {
+        for (ns = cur->nsDef; ns != NULL; ns = ns->next) {
+            /* 
+             * first of all ignore default "xml" namespace and 
+             * already included namespace
+             */
+            if ((xmlC14NIsXmlNs(ns)) || (xmlListSearch(list, ns) != NULL)) {
+                continue;
+            }
 
-	    /*
-	     * Lookup nearest namespace after visible parent having
-	     * the same prefix. Namespace included if and only if one of 
-	     * the following:
-	     *   - another namespace having the same prefix but 
-	     *   different value found or
-	     *   - there is no namespaces having the same prefix and  
-	     *   it is not a default xmlns="" namespace (empty prefix 
-	     *   and empty href)
-	     */
-	    prev = xmlSearchNs(ctx->doc, visible_parent, ns->prefix);
-	    if(prev == NULL && (xmlStrlen(ns->prefix) > 0 || xmlStrlen(ns->href) > 0)) {
-		xmlListInsert(list, ns);
-	    } else if(prev != NULL && !xmlStrEqual(ns->href, prev->href)) {
-	        xmlListInsert(list, ns);
-	    }
-	}
-	cur = cur->parent;
+            /*
+             * Lookup nearest namespace after visible parent having
+             * the same prefix. Namespace included if and only if one of 
+             * the following:
+             *   - another namespace having the same prefix but 
+             *   different value found or
+             *   - there is no namespaces having the same prefix and  
+             *   it is not a default xmlns="" namespace (empty prefix 
+             *   and empty href)
+             */
+            prev = xmlSearchNs(ctx->doc, visible_parent, ns->prefix);
+            if ((prev == NULL) && ((xmlStrlen(ns->prefix) > 0) ||
+                                   (xmlStrlen(ns->href) > 0))) {
+                xmlListInsert(list, ns);
+            } else if ((prev != NULL)
+                       && (!xmlStrEqual(ns->href, prev->href))) {
+                xmlListInsert(list, ns);
+            }
+        }
+        cur = cur->parent;
     }
 
     /* 
      * print out all elements from list 
      */
-    xmlListWalk(list, (xmlListWalker)xmlC14NPrintNamespaces, (const void*)ctx);
-    
+    xmlListWalk(list, (xmlListWalker) xmlC14NPrintNamespaces,
+                (const void *) ctx);
+
     /* 
      * Cleanup
      */
     xmlListDelete(list);
-    return(0);
+    return (0);
 }
 
 /**
@@ -360,39 +378,41 @@
  * Returns 0 on success or -1 on fail.
  */
 static int
-xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
+xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
     xmlListPtr list;
     xmlAttrPtr attr;
     xmlNsPtr ns;
-            
-    if(ctx == NULL || cur == NULL || cur->type != XML_ELEMENT_NODE) {
-#ifdef DEBUG_C14N    
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-            "xmlExcC14NProcessNamespacesAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
-#endif	
-        return(-1);
-    }    
-    
-    if(!ctx->exclusive || ctx->ns_rendered == NULL) {
-#ifdef DEBUG_C14N    
-        xmlGenericError(xmlGenericErrorContext,
-            "xmlExcC14NProcessNamespacesAxis: called for non-exclusive canonization or rendered stack is NULL.\n");
-#endif	
-        return(-1);
-	
+                        "xmlExcC14NProcessNamespacesAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
+#endif
+        return (-1);
     }
-    
+
+    if ((!ctx->exclusive) || (ctx->ns_rendered == NULL)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlExcC14NProcessNamespacesAxis: called for non-exclusive canonization or rendered stack is NULL.\n");
+#endif
+        return (-1);
+
+    }
+
     /*
      * Create a sorted list to store element namespaces
      */
-    list = xmlListCreate(NULL, (xmlListDataCompare)xmlC14NNamespacesCompare);
-    if(list == NULL) {
+    list =
+        xmlListCreate(NULL, (xmlListDataCompare) xmlC14NNamespacesCompare);
+    if (list == NULL) {
 #ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-		"xmlExcC14NProcessNamespacesAxis: list creation failed\n");
+                        "xmlExcC14NProcessNamespacesAxis: list creation failed\n");
 #endif
-	return(-1);
-    }    
+        return (-1);
+    }
 
     /*
      * First of all, add all namespaces required by current node
@@ -400,67 +420,72 @@
      * todo: do we need to check for default "xml:" namespace
      */
     ns = (cur->ns != NULL) ? cur->ns : xmlSearchNs(ctx->doc, cur, NULL);
-    if(ns != NULL && !xmlC14NIsXmlNs(ns) && xmlListSearch(list, ns) == NULL) {
-	if(!xmlExcC14NIsRendered(ctx, ns)) {
-		xmlListInsert(list, ns);
-		xmlXPathNodeSetAdd(ctx->ns_rendered, (xmlNodePtr)ns);
-	}
+    if ((ns != NULL) && (!xmlC14NIsXmlNs(ns)) &&
+        (xmlListSearch(list, ns) == NULL)) {
+        if (!xmlExcC14NIsRendered(ctx, ns)) {
+            xmlListInsert(list, ns);
+            xmlXPathNodeSetAdd(ctx->ns_rendered, (xmlNodePtr) ns);
+        }
     }
     attr = cur->properties;
-    while (attr != NULL) { 
-	/* 
-	 * todo: do we need to check that attribute is visible and has non
-	 * default namespace
-	 */
-	if(xmlC14NIsVisible(ctx, attr)) {
-	    ns = (attr->ns != NULL) ? attr->ns : xmlSearchNs(ctx->doc, cur, NULL);
-	    if(ns != NULL && xmlC14NIsVisible(ctx, attr) && !xmlC14NIsXmlNs(ns)) {
-		if(xmlListSearch(list, ns) == NULL && 
-		    !xmlExcC14NIsRendered(ctx, ns)) {
-			xmlListInsert(list, ns);
-			xmlXPathNodeSetAdd(ctx->ns_rendered, (xmlNodePtr)ns);
-		}
-	    }
-	}
-	attr = attr->next;
+    while (attr != NULL) {
+        /* 
+         * todo: do we need to check that attribute is visible and has non
+         * default namespace
+         */
+        if (xmlC14NIsVisible(ctx, attr)) {
+            ns = (attr->ns != NULL) ? attr->ns : xmlSearchNs(ctx->doc, cur,
+                                                             NULL);
+            if ((ns != NULL) && (xmlC14NIsVisible(ctx, attr)) &&
+                (!xmlC14NIsXmlNs(ns))) {
+                if ((xmlListSearch(list, ns) == NULL)
+                    && (!xmlExcC14NIsRendered(ctx, ns))) {
+                    xmlListInsert(list, ns);
+                    xmlXPathNodeSetAdd(ctx->ns_rendered, (xmlNodePtr) ns);
+                }
+            }
+        }
+        attr = attr->next;
     }
-        
+
     /* 
      * Next add all inclusive namespaces if needed. 
      */
-    if(ctx->inclusive_ns_prefixes != NULL) {
-	int i;
-	xmlChar *prefix;
-	
-	for(i = 0; ctx->inclusive_ns_prefixes[i] != NULL; ++i) {
-	    prefix = ctx->inclusive_ns_prefixes[i];
-	    /*
-	     * Special values for namespace with empty prefix
-	     */    
-	    if(xmlStrEqual(prefix, BAD_CAST "#default") || xmlStrEqual(prefix, BAD_CAST "")) {
-		prefix = NULL;
-	    }
-	    ns = xmlSearchNs(ctx->doc, cur, prefix);
-	    if(ns != NULL && !xmlC14NIsXmlNs(ns)) {
-		if(xmlListSearch(list, ns) == NULL && 
-		    !xmlExcC14NIsRendered(ctx, ns)) {
-			xmlListInsert(list, ns);
-			xmlXPathNodeSetAdd(ctx->ns_rendered, (xmlNodePtr)ns);
-		}
-	    }	    
-	}	
+    if (ctx->inclusive_ns_prefixes != NULL) {
+        int i;
+        xmlChar *prefix;
+
+        for (i = 0; ctx->inclusive_ns_prefixes[i] != NULL; ++i) {
+            prefix = ctx->inclusive_ns_prefixes[i];
+            /*
+             * Special values for namespace with empty prefix
+             */
+            if (xmlStrEqual(prefix, BAD_CAST "#default")
+                || xmlStrEqual(prefix, BAD_CAST "")) {
+                prefix = NULL;
+            }
+            ns = xmlSearchNs(ctx->doc, cur, prefix);
+            if ((ns != NULL) && (!xmlC14NIsXmlNs(ns))) {
+                if (xmlListSearch(list, ns) == NULL &&
+                    !xmlExcC14NIsRendered(ctx, ns)) {
+                    xmlListInsert(list, ns);
+                    xmlXPathNodeSetAdd(ctx->ns_rendered, (xmlNodePtr) ns);
+                }
+            }
+        }
     }
-        
+
     /* 
      * print out all elements from list 
      */
-    xmlListWalk(list, (xmlListWalker)xmlC14NPrintNamespaces, (const void*)ctx);
-    
+    xmlListWalk(list, (xmlListWalker) xmlC14NPrintNamespaces,
+                (const void *) ctx);
+
     /* 
      * Cleanup
      */
     xmlListDelete(list);
-    return(0);
+    return (0);
 }
 
 
@@ -474,17 +499,21 @@
  * Returns -1 if attr1 < attr2, 0 if attr1 == attr2 or 1 if attr1 > attr2.
  */
 static int
-xmlC14NAttrsCompare(xmlAttrPtr attr1, xmlAttrPtr attr2) {
+xmlC14NAttrsCompare(xmlAttrPtr attr1, xmlAttrPtr attr2)
+{
     int ret = 0;
 
     /*
      * Simple cases
      */
-    if(attr1 == attr2) return(0);
-    if(attr1 == NULL) return(-1);
-    if(attr2 == NULL) return(1);
-    if(attr1->ns == attr2->ns) {
-	return(xmlStrcmp(attr1->name, attr2->name));        
+    if (attr1 == attr2)
+        return (0);
+    if (attr1 == NULL)
+        return (-1);
+    if (attr2 == NULL)
+        return (1);
+    if (attr1->ns == attr2->ns) {
+        return (xmlStrcmp(attr1->name, attr2->name));
     }
 
     /* 
@@ -492,16 +521,20 @@
      * because the default namespace is not applied to
      * unqualified attributes
      */
-    if(attr1->ns == NULL) return(-1);
-    if(attr2->ns == NULL) return(1);
-    if(attr1->ns->prefix == NULL) return(-1);
-    if(attr2->ns->prefix == NULL) return(1);
-    
+    if (attr1->ns == NULL)
+        return (-1);
+    if (attr2->ns == NULL)
+        return (1);
+    if (attr1->ns->prefix == NULL)
+        return (-1);
+    if (attr2->ns->prefix == NULL)
+        return (1);
+
     ret = xmlStrcmp(attr1->ns->href, attr2->ns->href);
-    if(ret == 0) {
-	ret = xmlStrcmp(attr1->name, attr2->name);
+    if (ret == 0) {
+        ret = xmlStrcmp(attr1->name, attr2->name);
     }
-    return(ret);
+    return (ret);
 }
 
 
@@ -518,44 +551,46 @@
  * Returns 1 on success or 0 on fail.
  */
 static int
-xmlC14NPrintAttrs(const xmlAttrPtr attr, xmlC14NCtxPtr ctx) {
+xmlC14NPrintAttrs(const xmlAttrPtr attr, xmlC14NCtxPtr ctx)
+{
     xmlChar *value;
     xmlChar *buffer;
 
-    if(attr == NULL || ctx == NULL) {
+    if ((attr == NULL) || (ctx == NULL)) {
 #ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NPrintAttrs: attr == NULL or ctx == NULL\n");
+                        "xmlC14NPrintAttrs: attr == NULL or ctx == NULL\n");
 #endif
-	return(0);
+        return (0);
     }
 
     xmlOutputBufferWriteString(ctx->buf, " ");
-    if(attr->ns != NULL && xmlStrlen(attr->ns->prefix) > 0) {
-        xmlOutputBufferWriteString(ctx->buf, (const char *) attr->ns->prefix);
-        xmlOutputBufferWriteString(ctx->buf, ":");   
+    if (attr->ns != NULL && xmlStrlen(attr->ns->prefix) > 0) {
+        xmlOutputBufferWriteString(ctx->buf,
+                                   (const char *) attr->ns->prefix);
+        xmlOutputBufferWriteString(ctx->buf, ":");
     }
     xmlOutputBufferWriteString(ctx->buf, (const char *) attr->name);
     xmlOutputBufferWriteString(ctx->buf, "=\"");
 
     value = xmlNodeListGetString(attr->doc, attr->children, 1);
     /* todo: should we log an error if value==NULL ? */
-    if(value != NULL) {
-	buffer = xmlC11NNormalizeAttr(value);
-	xmlFree(value);
-	if (buffer != NULL) {
-    	    xmlOutputBufferWriteString(ctx->buf, (const char *)buffer);
-    	    xmlFree(buffer);
-	} else {
+    if (value != NULL) {
+        buffer = xmlC11NNormalizeAttr(value);
+        xmlFree(value);
+        if (buffer != NULL) {
+            xmlOutputBufferWriteString(ctx->buf, (const char *) buffer);
+            xmlFree(buffer);
+        } else {
 #ifdef DEBUG_C14N
-	    xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NPrintAttrs: xmlC11NNormalizeAttr failed\n");
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NPrintAttrs: xmlC11NNormalizeAttr failed\n");
 #endif
-	    return(0);
-	}
+            return (0);
+        }
     }
     xmlOutputBufferWriteString(ctx->buf, "\"");
-    return(1);
+    return (1);
 }
 
 /**
@@ -590,76 +625,80 @@
  * Returns 0 on success or -1 on fail.
  */
 static int
-xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
+xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
     xmlAttrPtr attr;
     xmlListPtr list;
-    
-    if(ctx == NULL || cur == NULL || cur->type != XML_ELEMENT_NODE) {
-#ifdef DEBUG_C14N    
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NProcessAttrsAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
-#endif	
-        return(-1);
-    }    
+                        "xmlC14NProcessAttrsAxis: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
+#endif
+        return (-1);
+    }
 
     /*
      * Create a sorted list to store element attributes
      */
-    list = xmlListCreate(NULL, (xmlListDataCompare)xmlC14NAttrsCompare);
-    if(list == NULL) {
+    list = xmlListCreate(NULL, (xmlListDataCompare) xmlC14NAttrsCompare);
+    if (list == NULL) {
 #ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NProcessAttrsAxis: list creation failed\n");
+                        "xmlC14NProcessAttrsAxis: list creation failed\n");
 #endif
-	return(-1);
+        return (-1);
     }
 
     /* 
      * Add all visible attributes from current node. 
      */
     attr = cur->properties;
-    while (attr != NULL) { 
-	/* check that attribute is visible */
-	if(xmlC14NIsVisible(ctx, attr)) {
-	    xmlListInsert(list, attr);
-	}
-	attr = attr->next;
+    while (attr != NULL) {
+        /* check that attribute is visible */
+        if (xmlC14NIsVisible(ctx, attr)) {
+            xmlListInsert(list, attr);
+        }
+        attr = attr->next;
     }
-    
+
     /* 
      * include attributes in "xml" namespace defined in ancestors
      * (only for non-exclusive XML Canonicalization)
      */
-    if(!ctx->exclusive && cur->parent != NULL && !xmlC14NIsVisible(ctx, cur->parent)) {    
+    if ((!ctx->exclusive) && (cur->parent != NULL)
+        && (!xmlC14NIsVisible(ctx, cur->parent))) {
         /*
-	 * If XPath node-set is not specified then the parent is always 
-	 * visible!
-	 */
-	 cur = cur->parent;
-	 while(cur != NULL) {
-	    attr = cur->properties;
-	    while (attr != NULL) { 
-		if(attr->ns != NULL && xmlStrEqual(attr->ns->prefix, BAD_CAST "xml")) {
-		    if(xmlListSearch(list, attr) == NULL) {
-			xmlListInsert(list, attr);
-		    }
-		}
-		attr = attr->next;
-	    }
-	    cur = cur->parent;
-	 }
+         * If XPath node-set is not specified then the parent is always 
+         * visible!
+         */
+        cur = cur->parent;
+        while (cur != NULL) {
+            attr = cur->properties;
+            while (attr != NULL) {
+                if ((attr->ns != NULL)
+                    && (xmlStrEqual(attr->ns->prefix, BAD_CAST "xml"))) {
+                    if (xmlListSearch(list, attr) == NULL) {
+                        xmlListInsert(list, attr);
+                    }
+                }
+                attr = attr->next;
+            }
+            cur = cur->parent;
+        }
     }
-    
+
     /* 
      * print out all elements from list 
      */
-    xmlListWalk(list, (xmlListWalker)xmlC14NPrintAttrs, (const void*)ctx);
-    
+    xmlListWalk(list, (xmlListWalker) xmlC14NPrintAttrs,
+                (const void *) ctx);
+
     /* 
      * Cleanup
      */
-    xmlListDelete(list);    
-    return(0);
+    xmlListDelete(list);
+    return (0);
 }
 
 /** 
@@ -672,43 +711,47 @@
  * Returns 0 if the node has no relative namespaces or -1 otherwise.
  */
 static int
-xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
+xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
     xmlNsPtr ns;
-        
-    if(ctx == NULL || cur == NULL || cur->type != XML_ELEMENT_NODE) {
-#ifdef DEBUG_C14N    
-        xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NCheckForRelativeNamespaces: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
-#endif	
-        return(-1);
-    }    
 
-    ns = cur->nsDef; 
-    while(ns != NULL) {
-	if(xmlStrlen(ns->href) > 0) {
-	    xmlURIPtr uri;
-	    
-	    uri = xmlParseURI((const char *) ns->href);
-	    if(uri == NULL) {
-#ifdef DEBUG_C14N    
-    		xmlGenericError(xmlGenericErrorContext,
-        	    "xmlC14NCheckForRelativeNamespaces: unable to parse uri=\"%s\".\n", ns->href);
-#endif		
-		return(-1);
-	    }
-	    if(xmlStrlen((const xmlChar *) uri->scheme) == 0) {
-		xmlFreeURI(uri); 
-		return(-1);
-	    }
-	    if(!xmlStrEqual((const xmlChar *) uri->scheme, BAD_CAST "urn") && xmlStrlen((const xmlChar *) uri->server) == 0) {
-		xmlFreeURI(uri); 
-		return(-1);
-	    }
-	    xmlFreeURI(uri);   
-	}
-	ns = ns->next;
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NCheckForRelativeNamespaces: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
+#endif
+        return (-1);
     }
-    return(0);
+
+    ns = cur->nsDef;
+    while (ns != NULL) {
+        if (xmlStrlen(ns->href) > 0) {
+            xmlURIPtr uri;
+
+            uri = xmlParseURI((const char *) ns->href);
+            if (uri == NULL) {
+#ifdef DEBUG_C14N
+                xmlGenericError(xmlGenericErrorContext,
+                                "xmlC14NCheckForRelativeNamespaces: unable to parse uri=\"%s\".\n",
+                                ns->href);
+#endif
+                return (-1);
+            }
+            if (xmlStrlen((const xmlChar *) uri->scheme) == 0) {
+                xmlFreeURI(uri);
+                return (-1);
+            }
+            if ((!xmlStrEqual
+                 ((const xmlChar *) uri->scheme, BAD_CAST "urn"))
+                && (xmlStrlen((const xmlChar *) uri->server) == 0)) {
+                xmlFreeURI(uri);
+                return (-1);
+            }
+            xmlFreeURI(uri);
+        }
+        ns = ns->next;
+    }
+    return (0);
 }
 
 /**
@@ -733,29 +776,30 @@
  * Returns non-negative value on success or negative value on fail
  */
 static int
-xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible) {
+xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
+{
     int ret;
     int ns_rendered_pos = 0;
 
-    if(ctx == NULL || cur == NULL || cur->type != XML_ELEMENT_NODE) {
-#ifdef DEBUG_C14N    
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NProcessElementNode: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
-#endif	
-        return(-1);
-    }    
+                        "xmlC14NProcessElementNode: Null context or node pointer or type != XML_ELEMENT_NODE.\n");
+#endif
+        return (-1);
+    }
 
     /* 
      * Check relative relative namespaces:
      * implementations of XML canonicalization MUST report an operation
      * failure on documents containing relative namespace URIs.
      */
-    if(xmlC14NCheckForRelativeNamespaces(ctx, cur) < 0) {
-#ifdef DEBUG_C14N    
-    	xmlGenericError(xmlGenericErrorContext,
-    	    "xmlC14NProcessElementNode: xmlC14NCheckForRelativeNamespaces failed.\n");
-#endif	
-    	return(-1);
+    if (xmlC14NCheckForRelativeNamespaces(ctx, cur) < 0) {
+#ifdef DEBUG_C14N
+        xmlGenericError(xmlGenericErrorContext,
+                        "xmlC14NProcessElementNode: xmlC14NCheckForRelativeNamespaces failed.\n");
+#endif
+        return (-1);
     }
 
 
@@ -763,77 +807,79 @@
      * Save ns_rendered stack position for exclusive 
      * processing
      */
-    if(ctx->exclusive && ctx->ns_rendered != NULL) {
-	ns_rendered_pos = ctx->ns_rendered->nodeNr;
-    } 
+    if ((ctx->exclusive) && (ctx->ns_rendered != NULL)) {
+        ns_rendered_pos = ctx->ns_rendered->nodeNr;
+    }
 
-    if(visible) {
-	if(ctx->parent_is_doc) {
-	    ctx->pos = XMLC14N_INSIDE_DOCUMENT_ELEMENT;
-	} 
-	xmlOutputBufferWriteString(ctx->buf, "<");
+    if (visible) {
+        if (ctx->parent_is_doc) {
+            ctx->pos = XMLC14N_INSIDE_DOCUMENT_ELEMENT;
+        }
+        xmlOutputBufferWriteString(ctx->buf, "<");
 
-	if(cur->ns != NULL && xmlStrlen(cur->ns->prefix) > 0) {
-	    xmlOutputBufferWriteString(ctx->buf, (const char *)cur->ns->prefix);
-	    xmlOutputBufferWriteString(ctx->buf, ":");
-	}
-	xmlOutputBufferWriteString(ctx->buf, (const char *)cur->name);
+        if ((cur->ns != NULL) && (xmlStrlen(cur->ns->prefix) > 0)) {
+            xmlOutputBufferWriteString(ctx->buf,
+                                       (const char *) cur->ns->prefix);
+            xmlOutputBufferWriteString(ctx->buf, ":");
+        }
+        xmlOutputBufferWriteString(ctx->buf, (const char *) cur->name);
 
-	if(ctx->exclusive) {
-	    ret = xmlExcC14NProcessNamespacesAxis(ctx, cur);
-	} else {
-	    ret = xmlC14NProcessNamespacesAxis(ctx, cur);
-	}
-	if(ret < 0) {
-#ifdef DEBUG_C14N    
-    	    xmlGenericError(xmlGenericErrorContext,
-        	"xmlC14NProcessElementNode: xmlC14NProcessNamespacesAxis failed.\n");
-#endif	
-    	    return(-1);
-	}
-	
-	ret = xmlC14NProcessAttrsAxis(ctx, cur);
-	if(ret < 0) {
-#ifdef DEBUG_C14N    
-    	    xmlGenericError(xmlGenericErrorContext,
-        	"xmlC14NProcessElementNode: xmlC14NProcessAttrsAxis failed.\n");
-#endif	
-    	    return(-1);
-	}
+        if (ctx->exclusive) {
+            ret = xmlExcC14NProcessNamespacesAxis(ctx, cur);
+        } else {
+            ret = xmlC14NProcessNamespacesAxis(ctx, cur);
+        }
+        if (ret < 0) {
+#ifdef DEBUG_C14N
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NProcessElementNode: xmlC14NProcessNamespacesAxis failed.\n");
+#endif
+            return (-1);
+        }
 
-	xmlOutputBufferWriteString(ctx->buf, ">"); 
+        ret = xmlC14NProcessAttrsAxis(ctx, cur);
+        if (ret < 0) {
+#ifdef DEBUG_C14N
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NProcessElementNode: xmlC14NProcessAttrsAxis failed.\n");
+#endif
+            return (-1);
+        }
+
+        xmlOutputBufferWriteString(ctx->buf, ">");
     }
     if (cur->children != NULL) {
-	ret = xmlC14NProcessNodeList(ctx, cur->children);
-	if(ret < 0) {
-#ifdef DEBUG_C14N    
-	    xmlGenericError(xmlGenericErrorContext,
-    		"xmlC14NProcessElementNode: xmlC14NProcessNodeList failed.\n");
-#endif	
-    	    return(-1);
-	}
+        ret = xmlC14NProcessNodeList(ctx, cur->children);
+        if (ret < 0) {
+#ifdef DEBUG_C14N
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NProcessElementNode: xmlC14NProcessNodeList failed.\n");
+#endif
+            return (-1);
+        }
     }
-    if(visible) {
-	xmlOutputBufferWriteString(ctx->buf, "</");
-	if(cur->ns != NULL && xmlStrlen(cur->ns->prefix) > 0) {
-	    xmlOutputBufferWriteString(ctx->buf, (const char *)cur->ns->prefix);
-	    xmlOutputBufferWriteString(ctx->buf, ":");
-	}
-	xmlOutputBufferWriteString(ctx->buf, (const char *)cur->name);
-	xmlOutputBufferWriteString(ctx->buf, ">"); 
-	if(ctx->parent_is_doc) { 
-	    ctx->pos = XMLC14N_AFTER_DOCUMENT_ELEMENT; 
-	}
+    if (visible) {
+        xmlOutputBufferWriteString(ctx->buf, "</");
+        if ((cur->ns != NULL) && (xmlStrlen(cur->ns->prefix) > 0)) {
+            xmlOutputBufferWriteString(ctx->buf,
+                                       (const char *) cur->ns->prefix);
+            xmlOutputBufferWriteString(ctx->buf, ":");
+        }
+        xmlOutputBufferWriteString(ctx->buf, (const char *) cur->name);
+        xmlOutputBufferWriteString(ctx->buf, ">");
+        if (ctx->parent_is_doc) {
+            ctx->pos = XMLC14N_AFTER_DOCUMENT_ELEMENT;
+        }
     }
 
     /* 
      * Restore ns_rendered stack position for exclusive 
      * processing
      */
-    if(ctx->exclusive && ctx->ns_rendered != NULL) {
-	ctx->ns_rendered->nodeNr = ns_rendered_pos;
-    } 
-    return(0);
+    if ((ctx->exclusive) && (ctx->ns_rendered != NULL)) {
+        ctx->ns_rendered->nodeNr = ns_rendered_pos;
+    }
+    return (0);
 }
 
 /**
@@ -846,204 +892,199 @@
  * Returns non-negative value on success or negative value on fail
  */
 static int
-xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
+xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
     int ret = 0;
     int visible;
-    
-    if(ctx == NULL || cur == NULL) {
-#ifdef DEBUG_C14N    
+
+    if ((ctx == NULL) || (cur == NULL)) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NProcessNode: Null context or node pointer.\n");
-#endif	
-        return(-1);
+                        "xmlC14NProcessNode: Null context or node pointer.\n");
+#endif
+        return (-1);
     }
 
     visible = xmlC14NIsVisible(ctx, cur);
-    switch(cur->type) {
-	case XML_ELEMENT_NODE:
-	    ret = xmlC14NProcessElementNode(ctx, cur, visible);
-	    break;  
-	case XML_CDATA_SECTION_NODE:
-	case XML_TEXT_NODE:
-	    /*
-	     * Text Nodes
-	     * the string value, except all ampersands are replaced 
-	     * by &amp;, all open angle brackets (<) are replaced by &lt;, all closing 
-	     * angle brackets (>) are replaced by &gt;, and all #xD characters are 
-	     * replaced by &#xD;.
-	     */
-	     /* cdata sections are processed as text nodes */
-	     /* todo: verify that cdata sections are included in XPath nodes set */ 
-	    if(visible && cur->content != NULL) {
-		xmlChar *buffer;
+    switch (cur->type) {
+        case XML_ELEMENT_NODE:
+            ret = xmlC14NProcessElementNode(ctx, cur, visible);
+            break;
+        case XML_CDATA_SECTION_NODE:
+        case XML_TEXT_NODE:
+            /*
+             * Text Nodes
+             * the string value, except all ampersands are replaced 
+             * by &amp;, all open angle brackets (<) are replaced by &lt;, all closing 
+             * angle brackets (>) are replaced by &gt;, and all #xD characters are 
+             * replaced by &#xD;.
+             */
+            /* cdata sections are processed as text nodes */
+            /* todo: verify that cdata sections are included in XPath nodes set */
+            if ((visible) && (cur->content != NULL)) {
+                xmlChar *buffer;
 
-#ifndef XML_USE_BUFFER_CONTENT
-		buffer = xmlC11NNormalizeText(cur->content);
-#else
-		buffer = xmlC11NNormalizeText(xmlBufferContent(cur->content));
-#endif
-		if(buffer != NULL) {
-		    xmlOutputBufferWriteString(ctx->buf, (const char *)buffer);
-		    xmlFree(buffer);
-		} else {
+                buffer = xmlC11NNormalizeText(cur->content);
+                if (buffer != NULL) {
+                    xmlOutputBufferWriteString(ctx->buf,
+                                               (const char *) buffer);
+                    xmlFree(buffer);
+                } else {
 #ifdef DEBUG_C14N
-    		    xmlGenericError(xmlGenericErrorContext,
-			"xmlC14NProcessNode: xmlC11NNormalizeText() failed\n");
+                    xmlGenericError(xmlGenericErrorContext,
+                                    "xmlC14NProcessNode: xmlC11NNormalizeText() failed\n");
 #endif
-		    return(-1);
-		}
-	    }
-	    break;
-	case XML_PI_NODE:
-	    /* 
-	     * Processing Instruction (PI) Nodes- 
-	     * The opening PI symbol (<?), the PI target name of the node, 
-	     * a leading space and the string value if it is not empty, and 
-	     * the closing PI symbol (?>). If the string value is empty, 
-	     * then the leading space is not added. Also, a trailing #xA is 
-	     * rendered after the closing PI symbol for PI children of the 
-	     * root node with a lesser document order than the document 
-	     * element, and a leading #xA is rendered before the opening PI 
-	     * symbol of PI children of the root node with a greater document 
-	     * order than the document element.
-	     */	    
-	    if(visible) {
-		if(ctx->pos == XMLC14N_AFTER_DOCUMENT_ELEMENT) {
-		    xmlOutputBufferWriteString(ctx->buf, "\x0A<?");
-		} else {
-		    xmlOutputBufferWriteString(ctx->buf, "<?");
-		}
+                    return (-1);
+                }
+            }
+            break;
+        case XML_PI_NODE:
+            /* 
+             * Processing Instruction (PI) Nodes- 
+             * The opening PI symbol (<?), the PI target name of the node, 
+             * a leading space and the string value if it is not empty, and 
+             * the closing PI symbol (?>). If the string value is empty, 
+             * then the leading space is not added. Also, a trailing #xA is 
+             * rendered after the closing PI symbol for PI children of the 
+             * root node with a lesser document order than the document 
+             * element, and a leading #xA is rendered before the opening PI 
+             * symbol of PI children of the root node with a greater document 
+             * order than the document element.
+             */
+            if (visible) {
+                if (ctx->pos == XMLC14N_AFTER_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "\x0A<?");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "<?");
+                }
 
-		xmlOutputBufferWriteString(ctx->buf, (const char *)cur->name);
-		if(cur->content != NULL && *(cur->content) != '\0') {
-		    xmlChar *buffer;
-		    xmlOutputBufferWriteString(ctx->buf, " ");
-		    
-		    /* todo: do we need to normalize pi? */
-#ifndef XML_USE_BUFFER_CONTENT
-		    buffer = xmlC11NNormalizePI(cur->content);
-#else
-		    buffer = xmlC11NNormalizePI(xmlBufferContent(cur->content));
-#endif
-		    if (buffer != NULL) {
-			xmlOutputBufferWriteString(ctx->buf, (const char *)buffer);
-			xmlFree(buffer);
-		    } else {
+                xmlOutputBufferWriteString(ctx->buf,
+                                           (const char *) cur->name);
+                if ((cur->content != NULL) && (*(cur->content) != '\0')) {
+                    xmlChar *buffer;
+
+                    xmlOutputBufferWriteString(ctx->buf, " ");
+
+                    /* todo: do we need to normalize pi? */
+                    buffer = xmlC11NNormalizePI(cur->content);
+                    if (buffer != NULL) {
+                        xmlOutputBufferWriteString(ctx->buf,
+                                                   (const char *) buffer);
+                        xmlFree(buffer);
+                    } else {
 #ifdef DEBUG_C14N
-    			xmlGenericError(xmlGenericErrorContext,
-			    "xmlC14NProcessNode: xmlC11NNormalizePI() failed\n");
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "xmlC14NProcessNode: xmlC11NNormalizePI() failed\n");
 #endif
-			return(-1);
-		    }
-		}
+                        return (-1);
+                    }
+                }
 
-		if(ctx->pos == XMLC14N_BEFORE_DOCUMENT_ELEMENT) {
-    		    xmlOutputBufferWriteString(ctx->buf, "?>\x0A");
-		} else {
-    		    xmlOutputBufferWriteString(ctx->buf, "?>");
-		}
-	    }
-	    break;
-	case XML_COMMENT_NODE:
-	    /*
-	     * Comment Nodes
-	     * Nothing if generating canonical XML without  comments. For 
-	     * canonical XML with comments, generate the opening comment 
-	     * symbol (<!--), the string value of the node, and the 
-	     * closing comment symbol (-->). Also, a trailing #xA is rendered 
-	     * after the closing comment symbol for comment children of the 
-	     * root node with a lesser document order than the document 
-	     * element, and a leading #xA is rendered before the opening 
-	     * comment symbol of comment children of the root node with a 
-	     * greater document order than the document element. (Comment 
-	     * children of the root node represent comments outside of the 
-	     * top-level document element and outside of the document type 
-	     * declaration).
-	     */
-	    if(visible && ctx->with_comments) {		
-		if(ctx->pos == XMLC14N_AFTER_DOCUMENT_ELEMENT) {
-		    xmlOutputBufferWriteString(ctx->buf, "\x0A<!--");
-		} else {
-		    xmlOutputBufferWriteString(ctx->buf, "<!--");
-		}
+                if (ctx->pos == XMLC14N_BEFORE_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "?>\x0A");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "?>");
+                }
+            }
+            break;
+        case XML_COMMENT_NODE:
+            /*
+             * Comment Nodes
+             * Nothing if generating canonical XML without  comments. For 
+             * canonical XML with comments, generate the opening comment 
+             * symbol (<!--), the string value of the node, and the 
+             * closing comment symbol (-->). Also, a trailing #xA is rendered 
+             * after the closing comment symbol for comment children of the 
+             * root node with a lesser document order than the document 
+             * element, and a leading #xA is rendered before the opening 
+             * comment symbol of comment children of the root node with a 
+             * greater document order than the document element. (Comment 
+             * children of the root node represent comments outside of the 
+             * top-level document element and outside of the document type 
+             * declaration).
+             */
+            if (visible && ctx->with_comments) {
+                if (ctx->pos == XMLC14N_AFTER_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "\x0A<!--");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "<!--");
+                }
 
-		if(cur->content != NULL) {
-		    xmlChar *buffer;
+                if (cur->content != NULL) {
+                    xmlChar *buffer;
 
-		    /* todo: do we need to normalize comment? */
-#ifndef XML_USE_BUFFER_CONTENT
-		    buffer = xmlC11NNormalizeComment(cur->content);
-#else
-		    buffer = xmlC11NNormalizeString(xmlBufferContent(cur->content));
-#endif
-		    if (buffer != NULL) {
-			xmlOutputBufferWriteString(ctx->buf, (const char *)buffer);
-			xmlFree(buffer);
-		    } else {
+                    /* todo: do we need to normalize comment? */
+                    buffer = xmlC11NNormalizeComment(cur->content);
+                    if (buffer != NULL) {
+                        xmlOutputBufferWriteString(ctx->buf,
+                                                   (const char *) buffer);
+                        xmlFree(buffer);
+                    } else {
 #ifdef DEBUG_C14N
-    			xmlGenericError(xmlGenericErrorContext,
-			    "xmlC14NProcessNode: xmlC11NNormalizeComment() failed\n");
+                        xmlGenericError(xmlGenericErrorContext,
+                                        "xmlC14NProcessNode: xmlC11NNormalizeComment() failed\n");
 #endif
-			return(-1);
-		    }
-		}
-		
-		if(ctx->pos == XMLC14N_BEFORE_DOCUMENT_ELEMENT) {
-    		    xmlOutputBufferWriteString(ctx->buf, "-->\x0A");
-		} else {
-    		    xmlOutputBufferWriteString(ctx->buf, "-->");
-		}
-	    }
-	    break;
-	case XML_DOCUMENT_NODE:
-	case XML_DOCUMENT_FRAG_NODE: /* should be processed as document? */
-	case XML_DOCB_DOCUMENT_NODE: /* should be processed as document? */
-	case XML_HTML_DOCUMENT_NODE: /* should be processed as document? */
-	    if (cur->children != NULL) {
-		ctx->pos = XMLC14N_BEFORE_DOCUMENT_ELEMENT;
-		ctx->parent_is_doc = 1;
-		ret = xmlC14NProcessNodeList(ctx, cur->children);
-	    }
-	    break;
+                        return (-1);
+                    }
+                }
 
-	case XML_ATTRIBUTE_NODE:
-    	    xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NProcessNode: XML_ATTRIBUTE_NODE is illegal here\n");
-	    return(-1);
-	case XML_NAMESPACE_DECL:
-    	    xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NProcessNode: XML_NAMESPACE_DECL is illegal here\n");
-	    return(-1);
-	case XML_ENTITY_REF_NODE:
-    	    xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NProcessNode: XML_ENTITY_REF_NODE is illegal here\n");
-	    return(-1);
-	case XML_ENTITY_NODE: 
-    	    xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NProcessNode: XML_ENTITY_NODE is illegal here\n");
-	    return(-1);
+                if (ctx->pos == XMLC14N_BEFORE_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "-->\x0A");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "-->");
+                }
+            }
+            break;
+        case XML_DOCUMENT_NODE:
+        case XML_DOCUMENT_FRAG_NODE:   /* should be processed as document? */
+        case XML_DOCB_DOCUMENT_NODE:   /* should be processed as document? */
+        case XML_HTML_DOCUMENT_NODE:   /* should be processed as document? */
+            if (cur->children != NULL) {
+                ctx->pos = XMLC14N_BEFORE_DOCUMENT_ELEMENT;
+                ctx->parent_is_doc = 1;
+                ret = xmlC14NProcessNodeList(ctx, cur->children);
+            }
+            break;
 
-	case XML_DOCUMENT_TYPE_NODE:
-	case XML_NOTATION_NODE:
-	case XML_DTD_NODE:
-	case XML_ELEMENT_DECL:
-	case XML_ATTRIBUTE_DECL:
-	case XML_ENTITY_DECL:
-	case XML_XINCLUDE_START:
-	case XML_XINCLUDE_END:
-	    /* 
-	     * should be ignored according to "W3C Canonical XML" 
-	     */
-	    break;
-	default:
+        case XML_ATTRIBUTE_NODE:
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NProcessNode: XML_ATTRIBUTE_NODE is illegal here\n");
+            return (-1);
+        case XML_NAMESPACE_DECL:
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NProcessNode: XML_NAMESPACE_DECL is illegal here\n");
+            return (-1);
+        case XML_ENTITY_REF_NODE:
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NProcessNode: XML_ENTITY_REF_NODE is illegal here\n");
+            return (-1);
+        case XML_ENTITY_NODE:
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NProcessNode: XML_ENTITY_NODE is illegal here\n");
+            return (-1);
+
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_NOTATION_NODE:
+        case XML_DTD_NODE:
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+            /* 
+             * should be ignored according to "W3C Canonical XML" 
+             */
+            break;
+        default:
 #ifdef DEBUG_C14N
-    	    xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NProcessNode: unknown node type = %d\n", cur->type);
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NProcessNode: unknown node type = %d\n",
+                            cur->type);
 #endif
-	    return(-1);
+            return (-1);
     }
 
-    return(ret);
+    return (ret);
 }
 
 /**
@@ -1056,21 +1097,22 @@
  * Returns non-negative value on success or negative value on fail
  */
 static int
-xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur) {
+xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
     int ret;
-    
-    if(ctx == NULL) {
-#ifdef DEBUG_C14N    
+
+    if (ctx == NULL) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NProcessNodeList: Null context pointer.\n");
-#endif	
-        return(-1);
+                        "xmlC14NProcessNodeList: Null context pointer.\n");
+#endif
+        return (-1);
     }
 
-    for(ret = 0; cur != NULL && ret >= 0; cur = cur->next) {
-	ret = xmlC14NProcessNode(ctx, cur);
-    }        
-    return(ret);
+    for (ret = 0; cur != NULL && ret >= 0; cur = cur->next) {
+        ret = xmlC14NProcessNode(ctx, cur);
+    }
+    return (ret);
 }
 
 
@@ -1082,17 +1124,18 @@
  */
 
 static void
-xmlC14NFreeCtx(xmlC14NCtxPtr ctx) {
-    if(ctx == NULL) {
+xmlC14NFreeCtx(xmlC14NCtxPtr ctx)
+{
+    if (ctx == NULL) {
 #ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-		"xmlC14NFreeCtx: ctx == NULL\n");
+                        "xmlC14NFreeCtx: ctx == NULL\n");
 #endif
-	return;
+        return;
     }
-    
-    if(ctx->ns_rendered != NULL) {
-	xmlXPathFreeNodeSet(ctx->ns_rendered);
+
+    if (ctx->ns_rendered != NULL) {
+        xmlXPathFreeNodeSet(ctx->ns_rendered);
     }
     xmlFree(ctx);
 }
@@ -1118,37 +1161,37 @@
  * Returns pointer to newly created object (success) or NULL (fail)
  */
 static xmlC14NCtxPtr
-xmlC14NNewCtx(xmlDocPtr doc, xmlNodeSetPtr nodes, 
-		int exclusive, xmlChar **inclusive_ns_prefixes,
-		int with_comments, 
-		xmlOutputBufferPtr buf) {
+xmlC14NNewCtx(xmlDocPtr doc, xmlNodeSetPtr nodes,
+              int exclusive, xmlChar ** inclusive_ns_prefixes,
+              int with_comments, xmlOutputBufferPtr buf)
+{
     xmlC14NCtxPtr ctx;
 
-    if(doc == NULL || buf == NULL) {
+    if ((doc == NULL) || (buf == NULL)) {
 #ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-	    "xmlC14NNewCtx: pointer to document or output buffer is NULL\n");
+                        "xmlC14NNewCtx: pointer to document or output buffer is NULL\n");
 #endif
-	return(NULL);
+        return (NULL);
     }
 
     /*
      *  Validate the encoding output buffer encoding
      */
-    if(buf->encoder != NULL) {
+    if (buf->encoder != NULL) {
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NNewCtx: output buffer encoder != NULL but C14N requires UTF8 output\n");
-        return(NULL);
+                        "xmlC14NNewCtx: output buffer encoder != NULL but C14N requires UTF8 output\n");
+        return (NULL);
     }
 
     /*
      *  Validate the XML document encoding value, if provided.
      */
-    if(doc->charset != XML_CHAR_ENCODING_UTF8) {
+    if (doc->charset != XML_CHAR_ENCODING_UTF8) {
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NNewCtx: source document not in UTF8\n");
-        return(NULL);
-    } 
+                        "xmlC14NNewCtx: source document not in UTF8\n");
+        return (NULL);
+    }
 
     /*
      * Allocate a new xmlC14NCtxPtr and fill the fields.
@@ -1156,14 +1199,14 @@
     ctx = (xmlC14NCtxPtr) xmlMalloc(sizeof(xmlC14NCtx));
     if (ctx == NULL) {
         xmlGenericError(xmlGenericErrorContext,
-	    "xmlC14NNewCtx: malloc failed\n");
-	return(NULL);
+                        "xmlC14NNewCtx: malloc failed\n");
+        return (NULL);
     }
     memset(ctx, 0, sizeof(xmlC14NCtx));
 
     /*
      * initialize C14N context
-     */    
+     */
     ctx->doc = doc;
     ctx->with_comments = with_comments;
     ctx->visible_nodes = nodes;
@@ -1175,12 +1218,12 @@
      * Set "exclusive" flag, create a nodes set for namespaces
      * stack and remember list of incluseve prefixes
      */
-    if(exclusive) {
-	ctx->exclusive = 1;
-	ctx->ns_rendered = xmlXPathNodeSetCreate(NULL);
+    if (exclusive) {
+        ctx->exclusive = 1;
+        ctx->ns_rendered = xmlXPathNodeSetCreate(NULL);
         ctx->inclusive_ns_prefixes = inclusive_ns_prefixes;
     }
-    return(ctx);
+    return (ctx);
 }
 
 /**
@@ -1206,36 +1249,36 @@
  * Returns non-negative value on success or a negative value on fail  
  */
 int
-xmlC14NDocSaveTo(xmlDocPtr doc, xmlNodeSetPtr nodes, 
-		int exclusive, xmlChar **inclusive_ns_prefixes,
-		int with_comments, 
-		xmlOutputBufferPtr buf) {
+xmlC14NDocSaveTo(xmlDocPtr doc, xmlNodeSetPtr nodes,
+                 int exclusive, xmlChar ** inclusive_ns_prefixes,
+                 int with_comments, xmlOutputBufferPtr buf)
+{
     xmlC14NCtxPtr ctx;
     int ret;
-    
-    if(buf == NULL || doc == NULL) {
-#ifdef DEBUG_C14N 	
+
+    if ((buf == NULL) || (doc == NULL)) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NDocSaveTo: null return buffer or doc pointer\n");
-#endif 	    
-        return(-1);
+                        "xmlC14NDocSaveTo: null return buffer or doc pointer\n");
+#endif
+        return (-1);
     }
 
     /*
      *  Validate the encoding output buffer encoding
      */
-    if(buf->encoder != NULL) {
+    if (buf->encoder != NULL) {
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NDocSaveTo: output buffer encoder != NULL but C14N requires UTF8 output\n");
-        return(-1);
+                        "xmlC14NDocSaveTo: output buffer encoder != NULL but C14N requires UTF8 output\n");
+        return (-1);
     }
 
     ctx = xmlC14NNewCtx(doc, nodes, exclusive, inclusive_ns_prefixes,
-		with_comments, buf);
-    if(ctx == NULL) {
+                        with_comments, buf);
+    if (ctx == NULL) {
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NDocSaveTo: unable to create C14N context\n");
-        return(-1);
+                        "xmlC14NDocSaveTo: unable to create C14N context\n");
+        return (-1);
     }
 
 
@@ -1248,36 +1291,36 @@
      * XML declaration, nor anything from within the document type 
      * declaration.
      */
-    if(doc->children != NULL) {
-	ret = xmlC14NProcessNodeList(ctx, doc->children);  
-	if(ret < 0) {
-#ifdef DEBUG_C14N    
-    	    xmlGenericError(xmlGenericErrorContext,
-        	"xmlC14NDocSaveTo: process childrens' list failed.\n");
-#endif	
-	    xmlC14NFreeCtx(ctx);    
-    	    return(-1);
-	}
-    }    
-    
+    if (doc->children != NULL) {
+        ret = xmlC14NProcessNodeList(ctx, doc->children);
+        if (ret < 0) {
+#ifdef DEBUG_C14N
+            xmlGenericError(xmlGenericErrorContext,
+                            "xmlC14NDocSaveTo: process childrens' list failed.\n");
+#endif
+            xmlC14NFreeCtx(ctx);
+            return (-1);
+        }
+    }
+
     /*
      * Flush buffer to get number of bytes written
      */
     ret = xmlOutputBufferFlush(buf);
-    if(ret < 0) {
-#ifdef DEBUG_C14N    
+    if (ret < 0) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-    	    "xmlC14NDocSaveTo: buffer flush failed.\n");
-#endif	
-	xmlC14NFreeCtx(ctx);    
-    	return(-1);
+                        "xmlC14NDocSaveTo: buffer flush failed.\n");
+#endif
+        xmlC14NFreeCtx(ctx);
+        return (-1);
     }
 
     /* 
      * Cleanup
      */
-    xmlC14NFreeCtx(ctx);    
-    return(ret);
+    xmlC14NFreeCtx(ctx);
+    return (ret);
 }
 
 /**
@@ -1303,63 +1346,63 @@
  * Returns the number of bytes written on success or a negative value on fail  
  */
 int
-xmlC14NDocDumpMemory(xmlDocPtr doc, xmlNodeSetPtr nodes, 
-		int exclusive, xmlChar **inclusive_ns_prefixes,
-		int with_comments, 
-		xmlChar **doc_txt_ptr) {
+xmlC14NDocDumpMemory(xmlDocPtr doc, xmlNodeSetPtr nodes,
+                     int exclusive, xmlChar ** inclusive_ns_prefixes,
+                     int with_comments, xmlChar ** doc_txt_ptr)
+{
     int ret;
     xmlOutputBufferPtr buf;
 
     if (doc_txt_ptr == NULL) {
-#ifdef DEBUG_C14N 	
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NDocDumpMemory:  null return buffer pointer\n");
-#endif 	    
-        return(-1);
+                        "xmlC14NDocDumpMemory:  null return buffer pointer\n");
+#endif
+        return (-1);
     }
 
     *doc_txt_ptr = NULL;
-    
+
     /*
      * create memory buffer with UTF8 (default) encoding 
      */
     buf = xmlAllocOutputBuffer(NULL);
-    if(buf == NULL ) {
-#ifdef DEBUG_C14N    
+    if (buf == NULL) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-	    "xmlC14NDocDumpMemory: failed to allocate output buffer.\n");
-#endif	    
-        return(-1);
+                        "xmlC14NDocDumpMemory: failed to allocate output buffer.\n");
+#endif
+        return (-1);
     }
 
     /*
      * canonize document and write to buffer
      */
-    ret = xmlC14NDocSaveTo(doc, nodes, exclusive, inclusive_ns_prefixes, 
-	    with_comments, buf);
-    if(ret < 0) {
-#ifdef DEBUG_C14N    
+    ret = xmlC14NDocSaveTo(doc, nodes, exclusive, inclusive_ns_prefixes,
+                           with_comments, buf);
+    if (ret < 0) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-	    "xmlC14NDocDumpMemory: xmlC14NDocSaveTo failed.\n");
-#endif	    
-	(void)xmlOutputBufferClose(buf);
-        return(-1);
-    }    
-
-    ret = buf->buffer->use;    
-    if(ret > 0) {
-	*doc_txt_ptr = xmlStrndup(buf->buffer->content, ret);
+                        "xmlC14NDocDumpMemory: xmlC14NDocSaveTo failed.\n");
+#endif
+        (void) xmlOutputBufferClose(buf);
+        return (-1);
     }
-    (void)xmlOutputBufferClose(buf);
 
-    if(*doc_txt_ptr == NULL && ret > 0) {
-#ifdef DEBUG_C14N 	
+    ret = buf->buffer->use;
+    if (ret > 0) {
+        *doc_txt_ptr = xmlStrndup(buf->buffer->content, ret);
+    }
+    (void) xmlOutputBufferClose(buf);
+
+    if ((*doc_txt_ptr == NULL) && (ret > 0)) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-                "xmlC14NDocDumpMemory: failed to allocate memory for document text representation\n");
-#endif 		
-	return(-1);
+                        "xmlC14NDocDumpMemory: failed to allocate memory for document text representation\n");
+#endif
+        return (-1);
     }
-    return(ret);        
+    return (ret);
 }
 
 /**
@@ -1387,56 +1430,57 @@
  * Returns the number of bytes written success or a negative value on fail  
  */
 int
-xmlC14NDocSave(xmlDocPtr doc, xmlNodeSetPtr nodes, 
-		int exclusive, xmlChar **inclusive_ns_prefixes,
-		int with_comments, 
-		const char* filename, int compression) {
-    xmlOutputBufferPtr buf;    
+xmlC14NDocSave(xmlDocPtr doc, xmlNodeSetPtr nodes,
+               int exclusive, xmlChar ** inclusive_ns_prefixes,
+               int with_comments, const char *filename, int compression)
+{
+    xmlOutputBufferPtr buf;
     int ret;
 
-    if(filename == NULL) {
-#ifdef DEBUG_C14N 	
+    if (filename == NULL) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NDocSave:  filename is NULL\n");
-#endif 	    
-        return(-1);
+                        "xmlC14NDocSave:  filename is NULL\n");
+#endif
+        return (-1);
     }
-    
 #ifdef HAVE_ZLIB_H
-    if(compression < 0) compression = xmlGetCompressMode();
-#endif    
+    if (compression < 0)
+        compression = xmlGetCompressMode();
+#endif
 
     /* 
      * save the content to a temp buffer, use default UTF8 encoding.
      */
     buf = xmlOutputBufferCreateFilename(filename, NULL, compression);
     if (buf == NULL) {
-#ifdef DEBUG_C14N 	
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-            "xmlC14NDocSave:  unable to create buffer for file=\"%s\" with compressin=%d\n", filename, compression);
-#endif 	    
-	return(-1);
+                        "xmlC14NDocSave:  unable to create buffer for file=\"%s\" with compressin=%d\n",
+                        filename, compression);
+#endif
+        return (-1);
     }
-    
+
     /*
      * canonize document and write to buffer
      */
-    ret = xmlC14NDocSaveTo(doc, nodes, exclusive, inclusive_ns_prefixes, 
-	    with_comments, buf);
-    if(ret < 0) {
-#ifdef DEBUG_C14N    
+    ret = xmlC14NDocSaveTo(doc, nodes, exclusive, inclusive_ns_prefixes,
+                           with_comments, buf);
+    if (ret < 0) {
+#ifdef DEBUG_C14N
         xmlGenericError(xmlGenericErrorContext,
-	    "xmlC14NDocSave: xmlC14NDocSaveTo failed.\n");
-#endif	    
-	(void)xmlOutputBufferClose(buf);
-        return(-1);
+                        "xmlC14NDocSave: xmlC14NDocSaveTo failed.\n");
+#endif
+        (void) xmlOutputBufferClose(buf);
+        return (-1);
     }
-    
+
     /* 
      * get the numbers of bytes written 
      */
     ret = xmlOutputBufferClose(buf);
-    return(ret);
+    return (ret);
 }
 
 
@@ -1467,13 +1511,16 @@
  * or NULL if an error occurs
  */
 static xmlChar *
-xmlC11NNormalizeString(const xmlChar *input, xmlC14NNormalizationMode mode) {
+xmlC11NNormalizeString(const xmlChar * input,
+                       xmlC14NNormalizationMode mode)
+{
     const xmlChar *cur = input;
     xmlChar *buffer = NULL;
     xmlChar *out = NULL;
     int buffer_size = 0;
 
-    if (input == NULL) return(NULL);
+    if (input == NULL)
+        return (NULL);
 
     /*
      * allocate an translation buffer.
@@ -1481,76 +1528,75 @@
     buffer_size = 1000;
     buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
     if (buffer == NULL) {
-	perror("malloc failed");
-	return(NULL);
+        perror("malloc failed");
+        return (NULL);
     }
     out = buffer;
 
     while (*cur != '\0') {
-        if (out - buffer > buffer_size - 10) {
-	    int indx = out - buffer;
+        if ((out - buffer) > (buffer_size - 10)) {
+            int indx = out - buffer;
 
-	    growBufferReentrant();
-	    out = &buffer[indx];
-	}
+            growBufferReentrant();
+            out = &buffer[indx];
+        }
 
-	if (*cur == '<' && (mode == XMLC14N_NORMALIZE_ATTR ||
-				mode == XMLC14N_NORMALIZE_TEXT)) {
-	    *out++ = '&';
-	    *out++ = 'l';
-	    *out++ = 't';
-	    *out++ = ';';
-	} else if (*cur == '>' && (mode == XMLC14N_NORMALIZE_TEXT)) {
-	    *out++ = '&';
-	    *out++ = 'g';
-	    *out++ = 't';
-	    *out++ = ';';
-	} else if (*cur == '&' && (mode == XMLC14N_NORMALIZE_ATTR ||
-				mode == XMLC14N_NORMALIZE_TEXT)) {
-	    *out++ = '&';
-	    *out++ = 'a';
-	    *out++ = 'm';
-	    *out++ = 'p';
-	    *out++ = ';';
-	} else if (*cur == '"' && (mode == XMLC14N_NORMALIZE_ATTR)) {
-	    *out++ = '&';
-	    *out++ = 'q';
-	    *out++ = 'u';
-	    *out++ = 'o';
-	    *out++ = 't';
-	    *out++ = ';';
-	} else if (*cur == '\x09' && (mode == XMLC14N_NORMALIZE_ATTR)) {
-	    *out++ = '&';
-	    *out++ = '#';
-	    *out++ = 'x';
-	    *out++ = '9';
-	    *out++ = ';';
-	} else if (*cur == '\x0A' && (mode == XMLC14N_NORMALIZE_ATTR)) {
-	    *out++ = '&';
-	    *out++ = '#';
-	    *out++ = 'x';
-	    *out++ = 'A';
-	    *out++ = ';';
-	} else if (*cur == '\x0D' && (mode == XMLC14N_NORMALIZE_ATTR ||
-				mode == XMLC14N_NORMALIZE_TEXT ||
-				mode == XMLC14N_NORMALIZE_COMMENT ||
-				mode == XMLC14N_NORMALIZE_PI)) {
-	    *out++ = '&';
-	    *out++ = '#';
-	    *out++ = 'x';
-	    *out++ = 'D';
-	    *out++ = ';';
-	} else {
-	    /*
-	     * Works because on UTF-8, all extended sequences cannot
-	     * result in bytes in the ASCII range.
-	     */
-	    *out++ = *cur;
-	}
-	cur++;
+        if ((*cur == '<') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
+                              (mode == XMLC14N_NORMALIZE_TEXT))) {
+            *out++ = '&';
+            *out++ = 'l';
+            *out++ = 't';
+            *out++ = ';';
+        } else if ((*cur == '>') && (mode == XMLC14N_NORMALIZE_TEXT)) {
+            *out++ = '&';
+            *out++ = 'g';
+            *out++ = 't';
+            *out++ = ';';
+        } else if ((*cur == '&') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
+                                     (mode == XMLC14N_NORMALIZE_TEXT))) {
+            *out++ = '&';
+            *out++ = 'a';
+            *out++ = 'm';
+            *out++ = 'p';
+            *out++ = ';';
+        } else if ((*cur == '"') && (mode == XMLC14N_NORMALIZE_ATTR)) {
+            *out++ = '&';
+            *out++ = 'q';
+            *out++ = 'u';
+            *out++ = 'o';
+            *out++ = 't';
+            *out++ = ';';
+        } else if ((*cur == '\x09') && (mode == XMLC14N_NORMALIZE_ATTR)) {
+            *out++ = '&';
+            *out++ = '#';
+            *out++ = 'x';
+            *out++ = '9';
+            *out++ = ';';
+        } else if ((*cur == '\x0A') && (mode == XMLC14N_NORMALIZE_ATTR)) {
+            *out++ = '&';
+            *out++ = '#';
+            *out++ = 'x';
+            *out++ = 'A';
+            *out++ = ';';
+        } else if ((*cur == '\x0D') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
+                                        (mode == XMLC14N_NORMALIZE_TEXT) ||
+                                        (mode == XMLC14N_NORMALIZE_COMMENT) ||
+					(mode == XMLC14N_NORMALIZE_PI))) {
+            *out++ = '&';
+            *out++ = '#';
+            *out++ = 'x';
+            *out++ = 'D';
+            *out++ = ';';
+        } else {
+            /*
+             * Works because on UTF-8, all extended sequences cannot
+             * result in bytes in the ASCII range.
+             */
+            *out++ = *cur;
+        }
+        cur++;
     }
     *out++ = 0;
-    return(buffer);
+    return (buffer);
 }
-
 #endif /* LIBXML_C14N_ENABLED */