nokolexbor 0.2.4 → 0.2.6

data/ext/nokolexbor/xml_chvalid.c

@@ -22,7 +22,7 @@
  * allowed.
  *
  */
-const unsigned char xmlIsPubidChar_tab[256] = {
+const unsigned char nl_xmlIsPubidChar_tab[256] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
     0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01,
@@ -96,13 +96,13 @@ static const xmlChSRange xmlIsBaseChar_srng[] = { {0x100, 0x131},
     {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc},
     {0x2126, 0x2126}, {0x212a, 0x212b}, {0x212e, 0x212e}, {0x2180, 0x2182},
     {0x3041, 0x3094}, {0x30a1, 0x30fa}, {0x3105, 0x312c}, {0xac00, 0xd7a3}};
-const xmlChRangeGroup xmlIsBaseCharGroup =
+const xmlChRangeGroup nl_xmlIsBaseCharGroup =
 	{197, 0, xmlIsBaseChar_srng, (xmlChLRangePtr)0};
 
 static const xmlChSRange xmlIsChar_srng[] = { {0x100, 0xd7ff},
     {0xe000, 0xfffd}};
 static const xmlChLRange xmlIsChar_lrng[] = { {0x10000, 0x10ffff}};
-const xmlChRangeGroup xmlIsCharGroup =
+const xmlChRangeGroup nl_xmlIsCharGroup =
 	{2, 1, xmlIsChar_srng, xmlIsChar_lrng};
 
 static const xmlChSRange xmlIsCombining_srng[] = { {0x300, 0x345},
@@ -130,7 +130,7 @@ static const xmlChSRange xmlIsCombining_srng[] = { {0x300, 0x345},
     {0xf90, 0xf95}, {0xf97, 0xf97}, {0xf99, 0xfad}, {0xfb1, 0xfb7},
     {0xfb9, 0xfb9}, {0x20d0, 0x20dc}, {0x20e1, 0x20e1}, {0x302a, 0x302f},
     {0x3099, 0x3099}, {0x309a, 0x309a}};
-const xmlChRangeGroup xmlIsCombiningGroup =
+const xmlChRangeGroup nl_xmlIsCombiningGroup =
 	{95, 0, xmlIsCombining_srng, (xmlChLRangePtr)0};
 
 static const xmlChSRange xmlIsDigit_srng[] = { {0x660, 0x669},
@@ -138,24 +138,24 @@ static const xmlChSRange xmlIsDigit_srng[] = { {0x660, 0x669},
     {0xae6, 0xaef}, {0xb66, 0xb6f}, {0xbe7, 0xbef}, {0xc66, 0xc6f},
     {0xce6, 0xcef}, {0xd66, 0xd6f}, {0xe50, 0xe59}, {0xed0, 0xed9},
     {0xf20, 0xf29}};
-const xmlChRangeGroup xmlIsDigitGroup =
+const xmlChRangeGroup nl_xmlIsDigitGroup =
 	{14, 0, xmlIsDigit_srng, (xmlChLRangePtr)0};
 
 static const xmlChSRange xmlIsExtender_srng[] = { {0x2d0, 0x2d0},
     {0x2d1, 0x2d1}, {0x387, 0x387}, {0x640, 0x640}, {0xe46, 0xe46},
     {0xec6, 0xec6}, {0x3005, 0x3005}, {0x3031, 0x3035}, {0x309d, 0x309e},
     {0x30fc, 0x30fe}};
-const xmlChRangeGroup xmlIsExtenderGroup =
+const xmlChRangeGroup nl_xmlIsExtenderGroup =
 	{10, 0, xmlIsExtender_srng, (xmlChLRangePtr)0};
 
 static const xmlChSRange xmlIsIdeographic_srng[] = { {0x3007, 0x3007},
     {0x3021, 0x3029}, {0x4e00, 0x9fa5}};
-const xmlChRangeGroup xmlIsIdeographicGroup =
+const xmlChRangeGroup nl_xmlIsIdeographicGroup =
 	{3, 0, xmlIsIdeographic_srng, (xmlChLRangePtr)0};
 
 
 /**
- * xmlCharInRange:
+ * nl_xmlCharInRange:
  * @val: character to be validated
  * @rptr: pointer to range to be used to validate
  *
@@ -165,7 +165,7 @@ const xmlChRangeGroup xmlIsIdeographicGroup =
  * Returns: true if character valid, false otherwise
  */
 int
-xmlCharInRange (unsigned int val, const xmlChRangeGroup *rptr) {
+nl_xmlCharInRange (unsigned int val, const xmlChRangeGroup *rptr) {
     int low, high, mid;
     const xmlChSRange *sptr;
     const xmlChLRange *lptr;
@@ -214,7 +214,7 @@ xmlCharInRange (unsigned int val, const xmlChRangeGroup *rptr) {
 
 
 /**
- * xmlIsBaseChar:
+ * nl_xmlIsBaseChar:
  * @ch:  character to validate
  *
  * This function is DEPRECATED.
@@ -223,13 +223,13 @@ xmlCharInRange (unsigned int val, const xmlChRangeGroup *rptr) {
  * Returns true if argument valid, false otherwise
  */
 int
-xmlIsBaseChar(unsigned int ch) {
+nl_xmlIsBaseChar(unsigned int ch) {
     return(xmlIsBaseCharQ(ch));
 }
 
 
 /**
- * xmlIsBlank:
+ * nl_xmlIsBlank:
  * @ch:  character to validate
  *
  * This function is DEPRECATED.
@@ -238,13 +238,13 @@ xmlIsBaseChar(unsigned int ch) {
  * Returns true if argument valid, false otherwise
  */
 int
-xmlIsBlank(unsigned int ch) {
+nl_xmlIsBlank(unsigned int ch) {
     return(xmlIsBlankQ(ch));
 }
 
 
 /**
- * xmlIsChar:
+ * nl_xmlIsChar:
  * @ch:  character to validate
  *
  * This function is DEPRECATED.
@@ -253,13 +253,13 @@ xmlIsBlank(unsigned int ch) {
  * Returns true if argument valid, false otherwise
  */
 int
-xmlIsChar(unsigned int ch) {
+nl_xmlIsChar(unsigned int ch) {
     return(xmlIsCharQ(ch));
 }
 
 
 /**
- * xmlIsCombining:
+ * nl_xmlIsCombining:
  * @ch:  character to validate
  *
  * This function is DEPRECATED.
@@ -268,13 +268,13 @@ xmlIsChar(unsigned int ch) {
  * Returns true if argument valid, false otherwise
  */
 int
-xmlIsCombining(unsigned int ch) {
+nl_xmlIsCombining(unsigned int ch) {
     return(xmlIsCombiningQ(ch));
 }
 
 
 /**
- * xmlIsDigit:
+ * nl_xmlIsDigit:
  * @ch:  character to validate
  *
  * This function is DEPRECATED.
@@ -283,13 +283,13 @@ xmlIsCombining(unsigned int ch) {
  * Returns true if argument valid, false otherwise
  */
 int
-xmlIsDigit(unsigned int ch) {
+nl_xmlIsDigit(unsigned int ch) {
     return(xmlIsDigitQ(ch));
 }
 
 
 /**
- * xmlIsExtender:
+ * nl_xmlIsExtender:
  * @ch:  character to validate
  *
  * This function is DEPRECATED.
@@ -298,13 +298,13 @@ xmlIsDigit(unsigned int ch) {
  * Returns true if argument valid, false otherwise
  */
 int
-xmlIsExtender(unsigned int ch) {
+nl_xmlIsExtender(unsigned int ch) {
     return(xmlIsExtenderQ(ch));
 }
 
 
 /**
- * xmlIsIdeographic:
+ * nl_xmlIsIdeographic:
  * @ch:  character to validate
  *
  * This function is DEPRECATED.
@@ -313,13 +313,13 @@ xmlIsExtender(unsigned int ch) {
  * Returns true if argument valid, false otherwise
  */
 int
-xmlIsIdeographic(unsigned int ch) {
+nl_xmlIsIdeographic(unsigned int ch) {
     return(xmlIsIdeographicQ(ch));
 }
 
 
 /**
- * xmlIsPubidChar:
+ * nl_xmlIsPubidChar:
  * @ch:  character to validate
  *
  * This function is DEPRECATED.
@@ -328,7 +328,7 @@ xmlIsIdeographic(unsigned int ch) {
  * Returns true if argument valid, false otherwise
  */
 int
-xmlIsPubidChar(unsigned int ch) {
+nl_xmlIsPubidChar(unsigned int ch) {
     return(xmlIsPubidCharQ(ch));
 }
 

data/ext/nokolexbor/xml_dict.c

@@ -142,12 +142,12 @@ static unsigned int rand_seed = 0;
 #endif
 
 /**
- * xmlInitializeDict:
+ * nl_xmlInitializeDict:
  *
- * DEPRECATED: Alias for xmlInitParser.
+ * DEPRECATED: Alias for nl_xmlInitParser.
  */
-int xmlInitializeDict(void) {
-    xmlInitParser();
+int nl_xmlInitializeDict(void) {
+    nl_xmlInitParser();
     return(0);
 }
 
@@ -175,19 +175,19 @@ int __xmlInitializeDict(void) {
 int __xmlRandom(void) {
     int ret;
 
-    xmlMutexLock(&xmlDictMutex);
+    nl_xmlMutexLock(&xmlDictMutex);
 #ifdef HAVE_RAND_R
     ret = rand_r(& rand_seed);
 #else
     ret = rand();
 #endif
-    xmlMutexUnlock(&xmlDictMutex);
+    nl_xmlMutexUnlock(&xmlDictMutex);
     return(ret);
 }
 #endif
 
 /**
- * xmlDictCleanup:
+ * nl_xmlDictCleanup:
  *
  * DEPRECATED: This function is a no-op. Call xmlCleanupParser
  * to free global state but see the warnings there. xmlCleanupParser
@@ -195,7 +195,7 @@ int __xmlRandom(void) {
  * have call cleanup functions at all.
  */
 void
-xmlDictCleanup(void) {
+nl_xmlDictCleanup(void) {
 }
 
 /**
@@ -248,7 +248,7 @@ xmlDictAddString(xmlDictPtr dict, const xmlChar *name, unsigned int namelen) {
 	else size *= 4; /* exponential growth */
         if (size < 4 * namelen)
 	    size = 4 * namelen; /* just in case ! */
-	pool = (xmlDictStringsPtr) xmlMalloc(sizeof(xmlDictStrings) + size);
+	pool = (xmlDictStringsPtr) nl_xmlMalloc(sizeof(xmlDictStrings) + size);
 	if (pool == NULL)
 	    return(NULL);
 	pool->size = size;
@@ -316,7 +316,7 @@ xmlDictAddQString(xmlDictPtr dict, const xmlChar *prefix, unsigned int plen,
 	else size *= 4; /* exponential growth */
         if (size < 4 * (namelen + plen + 1))
 	    size = 4 * (namelen + plen + 1); /* just in case ! */
-	pool = (xmlDictStringsPtr) xmlMalloc(sizeof(xmlDictStrings) + size);
+	pool = (xmlDictStringsPtr) nl_xmlMalloc(sizeof(xmlDictStrings) + size);
 	if (pool == NULL)
 	    return(NULL);
 	pool->size = size;
@@ -545,30 +545,30 @@ xmlDictComputeFastQKey(const xmlChar *prefix, int plen,
 }
 
 /**
- * xmlDictCreate:
+ * nl_xmlDictCreate:
  *
  * Create a new dictionary
  *
  * Returns the newly created dictionary, or NULL if an error occurred.
  */
 xmlDictPtr
-xmlDictCreate(void) {
+nl_xmlDictCreate(void) {
     xmlDictPtr dict;
 
-    xmlInitParser();
+    nl_xmlInitParser();
 
 #ifdef DICT_DEBUG_PATTERNS
     fprintf(stderr, "C");
 #endif
 
-    dict = xmlMalloc(sizeof(xmlDict));
+    dict = nl_xmlMalloc(sizeof(xmlDict));
     if (dict) {
         dict->ref_counter = 1;
         dict->limit = 0;
 
         dict->size = MIN_DICT_SIZE;
 	dict->nbElems = 0;
-        dict->dict = xmlMalloc(MIN_DICT_SIZE * sizeof(xmlDictEntry));
+        dict->dict = nl_xmlMalloc(MIN_DICT_SIZE * sizeof(xmlDictEntry));
 	dict->strings = NULL;
 	dict->subdict = NULL;
         if (dict->dict) {
@@ -580,13 +580,13 @@ xmlDictCreate(void) {
 #endif
 	    return(dict);
         }
-        xmlFree(dict);
+        nl_xmlFree(dict);
     }
     return(NULL);
 }
 
 /**
- * xmlDictCreateSub:
+ * nl_xmlDictCreateSub:
  * @sub: an existing dictionary
  *
  * Create a new dictionary, inheriting strings from the read-only
@@ -597,8 +597,8 @@ xmlDictCreate(void) {
  * Returns the newly created dictionary, or NULL if an error occurred.
  */
 xmlDictPtr
-xmlDictCreateSub(xmlDictPtr sub) {
-    xmlDictPtr dict = xmlDictCreate();
+nl_xmlDictCreateSub(xmlDictPtr sub) {
+    xmlDictPtr dict = nl_xmlDictCreate();
 
     if ((dict != NULL) && (sub != NULL)) {
 #ifdef DICT_DEBUG_PATTERNS
@@ -606,13 +606,13 @@ xmlDictCreateSub(xmlDictPtr sub) {
 #endif
         dict->seed = sub->seed;
         dict->subdict = sub;
-	xmlDictReference(dict->subdict);
+	nl_xmlDictReference(dict->subdict);
     }
     return(dict);
 }
 
 /**
- * xmlDictReference:
+ * nl_xmlDictReference:
  * @dict: the dictionary
  *
  * Increment the reference counter of a dictionary
@@ -620,11 +620,11 @@ xmlDictCreateSub(xmlDictPtr sub) {
  * Returns 0 in case of success and -1 in case of error
  */
 int
-xmlDictReference(xmlDictPtr dict) {
+nl_xmlDictReference(xmlDictPtr dict) {
     if (dict == NULL) return -1;
-    xmlMutexLock(&xmlDictMutex);
+    nl_xmlMutexLock(&xmlDictMutex);
     dict->ref_counter++;
-    xmlMutexUnlock(&xmlDictMutex);
+    nl_xmlMutexUnlock(&xmlDictMutex);
     return(0);
 }
 
@@ -667,7 +667,7 @@ xmlDictGrow(xmlDictPtr dict, size_t size) {
     if (oldsize == MIN_DICT_SIZE)
         keep_keys = 0;
 
-    dict->dict = xmlMalloc(size * sizeof(xmlDictEntry));
+    dict->dict = nl_xmlMalloc(size * sizeof(xmlDictEntry));
     if (dict->dict == NULL) {
 	dict->dict = olddict;
 	return(-1);
@@ -698,7 +698,7 @@ xmlDictGrow(xmlDictPtr dict, size_t size) {
 	} else {
 	    xmlDictEntryPtr entry;
 
-	    entry = xmlMalloc(sizeof(xmlDictEntry));
+	    entry = nl_xmlMalloc(sizeof(xmlDictEntry));
 	    if (entry != NULL) {
 		entry->name = olddict[i].name;
 		entry->len = olddict[i].len;
@@ -738,7 +738,7 @@ xmlDictGrow(xmlDictPtr dict, size_t size) {
 		dict->dict[key].next = NULL;
 		dict->dict[key].valid = 1;
 		dict->dict[key].okey = okey;
-		xmlFree(iter);
+		nl_xmlFree(iter);
 	    } else {
 		iter->next = dict->dict[key].next;
 		iter->okey = okey;
@@ -753,10 +753,10 @@ xmlDictGrow(xmlDictPtr dict, size_t size) {
 	}
     }
 
-    xmlFree(olddict);
+    nl_xmlFree(olddict);
 
 #ifdef DEBUG_GROW
-    xmlGenericError(xmlGenericErrorContext,
+    nl_xmlGenericError(nl_xmlGenericErrorContext,
 	    "xmlDictGrow : from %lu to %lu, %u elems\n", oldsize, size, nbElem);
 #endif
 
@@ -764,14 +764,14 @@ xmlDictGrow(xmlDictPtr dict, size_t size) {
 }
 
 /**
- * xmlDictFree:
+ * nl_xmlDictFree:
  * @dict: the dictionary
  *
  * Free the hash @dict and its contents. The userdata is
  * deallocated with @f if provided.
  */
 void
-xmlDictFree(xmlDictPtr dict) {
+nl_xmlDictFree(xmlDictPtr dict) {
     size_t i;
     xmlDictEntryPtr iter;
     xmlDictEntryPtr next;
@@ -782,17 +782,17 @@ xmlDictFree(xmlDictPtr dict) {
 	return;
 
     /* decrement the counter, it may be shared by a parser and docs */
-    xmlMutexLock(&xmlDictMutex);
+    nl_xmlMutexLock(&xmlDictMutex);
     dict->ref_counter--;
     if (dict->ref_counter > 0) {
-        xmlMutexUnlock(&xmlDictMutex);
+        nl_xmlMutexUnlock(&xmlDictMutex);
         return;
     }
 
-    xmlMutexUnlock(&xmlDictMutex);
+    nl_xmlMutexUnlock(&xmlDictMutex);
 
     if (dict->subdict != NULL) {
-        xmlDictFree(dict->subdict);
+        nl_xmlDictFree(dict->subdict);
     }
 
     if (dict->dict) {
@@ -804,25 +804,25 @@ xmlDictFree(xmlDictPtr dict) {
 	    while (iter) {
 		next = iter->next;
 		if (!inside_dict)
-		    xmlFree(iter);
+		    nl_xmlFree(iter);
 		dict->nbElems--;
 		inside_dict = 0;
 		iter = next;
 	    }
 	}
-	xmlFree(dict->dict);
+	nl_xmlFree(dict->dict);
     }
     pool = dict->strings;
     while (pool != NULL) {
         nextp = pool->next;
-	xmlFree(pool);
+	nl_xmlFree(pool);
 	pool = nextp;
     }
-    xmlFree(dict);
+    nl_xmlFree(dict);
 }
 
 /**
- * xmlDictLookup:
+ * nl_xmlDictLookup:
  * @dict: the dictionary
  * @name: the name of the userdata
  * @len: the length of the name, if -1 it is recomputed
@@ -832,7 +832,7 @@ xmlDictFree(xmlDictPtr dict) {
  * Returns the internal copy of the name or NULL in case of internal error
  */
 const xmlChar *
-xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
+nl_xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
     unsigned long key, okey, nbi = 0;
     xmlDictEntryPtr entry;
     xmlDictEntryPtr insert;
@@ -868,7 +868,7 @@ xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
 	    }
 #else
 	    if ((insert->okey == okey) && (insert->len == l) &&
-	        (!xmlStrncmp(insert->name, name, l)))
+	        (!nl_xmlStrncmp(insert->name, name, l)))
 		return(insert->name);
 #endif
 	    nbi++;
@@ -880,7 +880,7 @@ xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
 	}
 #else
 	if ((insert->okey == okey) && (insert->len == l) &&
-	    (!xmlStrncmp(insert->name, name, l)))
+	    (!nl_xmlStrncmp(insert->name, name, l)))
 	    return(insert->name);
 #endif
     }
@@ -910,7 +910,7 @@ xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
 		}
 #else
 		if ((tmp->okey == skey) && (tmp->len == l) &&
-		    (!xmlStrncmp(tmp->name, name, l)))
+		    (!nl_xmlStrncmp(tmp->name, name, l)))
 		    return(tmp->name);
 #endif
 		nbi++;
@@ -922,7 +922,7 @@ xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
 	    }
 #else
 	    if ((tmp->okey == skey) && (tmp->len == l) &&
-		(!xmlStrncmp(tmp->name, name, l)))
+		(!nl_xmlStrncmp(tmp->name, name, l)))
 		return(tmp->name);
 #endif
 	}
@@ -935,7 +935,7 @@ xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
     if (insert == NULL) {
 	entry = &(dict->dict[key]);
     } else {
-	entry = xmlMalloc(sizeof(xmlDictEntry));
+	entry = nl_xmlMalloc(sizeof(xmlDictEntry));
 	if (entry == NULL)
 	     return(NULL);
     }
@@ -962,7 +962,7 @@ xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
 }
 
 /**
- * xmlDictExists:
+ * nl_xmlDictExists:
  * @dict: the dictionary
  * @name: the name of the userdata
  * @len: the length of the name, if -1 it is recomputed
@@ -972,7 +972,7 @@ xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
  * Returns the internal copy of the name or NULL if not found.
  */
 const xmlChar *
-xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) {
+nl_xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) {
     unsigned long key, okey;
     xmlDictEntryPtr insert;
     unsigned int l;
@@ -1005,7 +1005,7 @@ xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) {
 	    }
 #else
 	    if ((insert->okey == okey) && (insert->len == l) &&
-	        (!xmlStrncmp(insert->name, name, l)))
+	        (!nl_xmlStrncmp(insert->name, name, l)))
 		return(insert->name);
 #endif
 	}
@@ -1016,7 +1016,7 @@ xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) {
 	}
 #else
 	if ((insert->okey == okey) && (insert->len == l) &&
-	    (!xmlStrncmp(insert->name, name, l)))
+	    (!nl_xmlStrncmp(insert->name, name, l)))
 	    return(insert->name);
 #endif
     }
@@ -1046,7 +1046,7 @@ xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) {
 		}
 #else
 		if ((tmp->okey == skey) && (tmp->len == l) &&
-		    (!xmlStrncmp(tmp->name, name, l)))
+		    (!nl_xmlStrncmp(tmp->name, name, l)))
 		    return(tmp->name);
 #endif
 	    }
@@ -1057,7 +1057,7 @@ xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) {
 	    }
 #else
 	    if ((tmp->okey == skey) && (tmp->len == l) &&
-		(!xmlStrncmp(tmp->name, name, l)))
+		(!nl_xmlStrncmp(tmp->name, name, l)))
 		return(tmp->name);
 #endif
 	}
@@ -1068,7 +1068,7 @@ xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) {
 }
 
 /**
- * xmlDictQLookup:
+ * nl_xmlDictQLookup:
  * @dict: the dictionary
  * @prefix: the prefix
  * @name: the name
@@ -1078,7 +1078,7 @@ xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) {
  * Returns the internal copy of the QName or NULL in case of internal error
  */
 const xmlChar *
-xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) {
+nl_xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) {
     unsigned long okey, key, nbi = 0;
     xmlDictEntryPtr entry;
     xmlDictEntryPtr insert;
@@ -1088,7 +1088,7 @@ xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) {
     if ((dict == NULL) || (name == NULL))
 	return(NULL);
     if (prefix == NULL)
-        return(xmlDictLookup(dict, name, -1));
+        return(nl_xmlDictLookup(dict, name, -1));
 
     l = len = strlen((const char *) name);
     plen = strlen((const char *) prefix);
@@ -1105,12 +1105,12 @@ xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) {
 	for (insert = &(dict->dict[key]); insert->next != NULL;
 	     insert = insert->next) {
 	    if ((insert->okey == okey) && (insert->len == len) &&
-	        (xmlStrQEqual(prefix, name, insert->name)))
+	        (nl_xmlStrQEqual(prefix, name, insert->name)))
 		return(insert->name);
 	    nbi++;
 	}
 	if ((insert->okey == okey) && (insert->len == len) &&
-	    (xmlStrQEqual(prefix, name, insert->name)))
+	    (nl_xmlStrQEqual(prefix, name, insert->name)))
 	    return(insert->name);
     }
 
@@ -1132,12 +1132,12 @@ xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) {
 	    for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL;
 		 tmp = tmp->next) {
 		if ((tmp->okey == skey) && (tmp->len == len) &&
-		    (xmlStrQEqual(prefix, name, tmp->name)))
+		    (nl_xmlStrQEqual(prefix, name, tmp->name)))
 		    return(tmp->name);
 		nbi++;
 	    }
 	    if ((tmp->okey == skey) && (tmp->len == len) &&
-		(xmlStrQEqual(prefix, name, tmp->name)))
+		(nl_xmlStrQEqual(prefix, name, tmp->name)))
 		return(tmp->name);
 	}
 	key = okey % dict->size;
@@ -1149,7 +1149,7 @@ xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) {
     if (insert == NULL) {
 	entry = &(dict->dict[key]);
     } else {
-	entry = xmlMalloc(sizeof(xmlDictEntry));
+	entry = nl_xmlMalloc(sizeof(xmlDictEntry));
 	if (entry == NULL)
 	     return(NULL);
     }
@@ -1173,7 +1173,7 @@ xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) {
 }
 
 /**
- * xmlDictOwns:
+ * nl_xmlDictOwns:
  * @dict: the dictionary
  * @str: the string
  *
@@ -1183,7 +1183,7 @@ xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) {
  * -1 in case of error
  */
 int
-xmlDictOwns(xmlDictPtr dict, const xmlChar *str) {
+nl_xmlDictOwns(xmlDictPtr dict, const xmlChar *str) {
     xmlDictStringsPtr pool;
 
     if ((dict == NULL) || (str == NULL))
@@ -1195,12 +1195,12 @@ xmlDictOwns(xmlDictPtr dict, const xmlChar *str) {
 	pool = pool->next;
     }
     if (dict->subdict)
-        return(xmlDictOwns(dict->subdict, str));
+        return(nl_xmlDictOwns(dict->subdict, str));
     return(0);
 }
 
 /**
- * xmlDictSize:
+ * nl_xmlDictSize:
  * @dict: the dictionary
  *
  * Query the number of elements installed in the hash @dict.
@@ -1209,7 +1209,7 @@ xmlDictOwns(xmlDictPtr dict, const xmlChar *str) {
  * -1 in case of error
  */
 int
-xmlDictSize(xmlDictPtr dict) {
+nl_xmlDictSize(xmlDictPtr dict) {
     if (dict == NULL)
 	return(-1);
     if (dict->subdict)
@@ -1218,7 +1218,7 @@ xmlDictSize(xmlDictPtr dict) {
 }
 
 /**
- * xmlDictSetLimit:
+ * nl_xmlDictSetLimit:
  * @dict: the dictionary
  * @limit: the limit in bytes
  *
@@ -1228,7 +1228,7 @@ xmlDictSize(xmlDictPtr dict) {
  * Returns the previous limit of the dictionary or 0
  */
 size_t
-xmlDictSetLimit(xmlDictPtr dict, size_t limit) {
+nl_xmlDictSetLimit(xmlDictPtr dict, size_t limit) {
     size_t ret;
 
     if (dict == NULL)
@@ -1239,7 +1239,7 @@ xmlDictSetLimit(xmlDictPtr dict, size_t limit) {
 }
 
 /**
- * xmlDictGetUsage:
+ * nl_xmlDictGetUsage:
  * @dict: the dictionary
  *
  * Get how much memory is used by a dictionary for strings
@@ -1248,7 +1248,7 @@ xmlDictSetLimit(xmlDictPtr dict, size_t limit) {
  * Returns the amount of strings allocated
  */
 size_t
-xmlDictGetUsage(xmlDictPtr dict) {
+nl_xmlDictGetUsage(xmlDictPtr dict) {
     xmlDictStringsPtr pool;
     size_t limit = 0;