Return-Path: X-Original-To: apmail-corinthia-commits-archive@minotaur.apache.org Delivered-To: apmail-corinthia-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 1F4DF17388 for ; Mon, 23 Mar 2015 10:46:42 +0000 (UTC) Received: (qmail 39607 invoked by uid 500); 23 Mar 2015 10:46:42 -0000 Delivered-To: apmail-corinthia-commits-archive@corinthia.apache.org Received: (qmail 39588 invoked by uid 500); 23 Mar 2015 10:46:41 -0000 Mailing-List: contact commits-help@corinthia.incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@corinthia.incubator.apache.org Delivered-To: mailing list commits@corinthia.incubator.apache.org Received: (qmail 39546 invoked by uid 99); 23 Mar 2015 10:46:41 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 23 Mar 2015 10:46:41 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED,T_RP_MATCHES_RCVD X-Spam-Check-By: apache.org Received: from [140.211.11.3] (HELO mail.apache.org) (140.211.11.3) by apache.org (qpsmtpd/0.29) with SMTP; Mon, 23 Mar 2015 10:46:15 +0000 Received: (qmail 37066 invoked by uid 99); 23 Mar 2015 10:45:54 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 23 Mar 2015 10:45:54 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 8B793E182A; Mon, 23 Mar 2015 10:45:54 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: jani@apache.org To: commits@corinthia.incubator.apache.org Date: Mon, 23 Mar 2015 10:46:27 -0000 Message-Id: In-Reply-To: <4396caf5bc7247e9afcf98c9473b9ec7@git.apache.org> References: <4396caf5bc7247e9afcf98c9473b9ec7@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [34/51] [abbrv] [partial] incubator-corinthia git commit: added libxml2 2.9.2 from xmlsoft.org X-Virus-Checked: Checked by ClamAV on apache.org http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/e181189e/DocFormats/platform/3rdparty/libxml2-2.9.2/dict.c ---------------------------------------------------------------------- diff --git a/DocFormats/platform/3rdparty/libxml2-2.9.2/dict.c b/DocFormats/platform/3rdparty/libxml2-2.9.2/dict.c new file mode 100644 index 0000000..5f71d55 --- /dev/null +++ b/DocFormats/platform/3rdparty/libxml2-2.9.2/dict.c @@ -0,0 +1,1259 @@ +/* + * dict.c: dictionary of reusable strings, just used to avoid allocation + * and freeing operations. + * + * Copyright (C) 2003-2012 Daniel Veillard. + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND + * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER. + * + * Author: daniel@veillard.com + */ + +#define IN_LIBXML +#include "libxml.h" + +#include +#ifdef HAVE_STDLIB_H +#include +#endif +#ifdef HAVE_TIME_H +#include +#endif + +/* + * Following http://www.ocert.org/advisories/ocert-2011-003.html + * it seems that having hash randomization might be a good idea + * when using XML with untrusted data + * Note1: that it works correctly only if compiled with WITH_BIG_KEY + * which is the default. + * Note2: the fast function used for a small dict won't protect very + * well but since the attack is based on growing a very big hash + * list we will use the BigKey algo as soon as the hash size grows + * over MIN_DICT_SIZE so this actually works + */ +#if defined(HAVE_RAND) && defined(HAVE_SRAND) && defined(HAVE_TIME) +#define DICT_RANDOMIZATION +#endif + +#include +#ifdef HAVE_STDINT_H +#include +#else +#ifdef HAVE_INTTYPES_H +#include +#elif defined(WIN32) +typedef unsigned __int32 uint32_t; +#endif +#endif +#include +#include +#include +#include +#include + +/* #define DEBUG_GROW */ +/* #define DICT_DEBUG_PATTERNS */ + +#define MAX_HASH_LEN 3 +#define MIN_DICT_SIZE 128 +#define MAX_DICT_HASH 8 * 2048 +#define WITH_BIG_KEY + +#ifdef WITH_BIG_KEY +#define xmlDictComputeKey(dict, name, len) \ + (((dict)->size == MIN_DICT_SIZE) ? \ + xmlDictComputeFastKey(name, len, (dict)->seed) : \ + xmlDictComputeBigKey(name, len, (dict)->seed)) + +#define xmlDictComputeQKey(dict, prefix, plen, name, len) \ + (((prefix) == NULL) ? \ + (xmlDictComputeKey(dict, name, len)) : \ + (((dict)->size == MIN_DICT_SIZE) ? \ + xmlDictComputeFastQKey(prefix, plen, name, len, (dict)->seed) : \ + xmlDictComputeBigQKey(prefix, plen, name, len, (dict)->seed))) + +#else /* !WITH_BIG_KEY */ +#define xmlDictComputeKey(dict, name, len) \ + xmlDictComputeFastKey(name, len, (dict)->seed) +#define xmlDictComputeQKey(dict, prefix, plen, name, len) \ + xmlDictComputeFastQKey(prefix, plen, name, len, (dict)->seed) +#endif /* WITH_BIG_KEY */ + +/* + * An entry in the dictionnary + */ +typedef struct _xmlDictEntry xmlDictEntry; +typedef xmlDictEntry *xmlDictEntryPtr; +struct _xmlDictEntry { + struct _xmlDictEntry *next; + const xmlChar *name; + unsigned int len; + int valid; + unsigned long okey; +}; + +typedef struct _xmlDictStrings xmlDictStrings; +typedef xmlDictStrings *xmlDictStringsPtr; +struct _xmlDictStrings { + xmlDictStringsPtr next; + xmlChar *free; + xmlChar *end; + size_t size; + size_t nbStrings; + xmlChar array[1]; +}; +/* + * The entire dictionnary + */ +struct _xmlDict { + int ref_counter; + + struct _xmlDictEntry *dict; + size_t size; + unsigned int nbElems; + xmlDictStringsPtr strings; + + struct _xmlDict *subdict; + /* used for randomization */ + int seed; + /* used to impose a limit on size */ + size_t limit; +}; + +/* + * A mutex for modifying the reference counter for shared + * dictionaries. + */ +static xmlRMutexPtr xmlDictMutex = NULL; + +/* + * Whether the dictionary mutex was initialized. + */ +static int xmlDictInitialized = 0; + +#ifdef DICT_RANDOMIZATION +#ifdef HAVE_RAND_R +/* + * Internal data for random function, protected by xmlDictMutex + */ +static unsigned int rand_seed = 0; +#endif +#endif + +/** + * xmlInitializeDict: + * + * Do the dictionary mutex initialization. + * this function is deprecated + * + * Returns 0 if initialization was already done, and 1 if that + * call led to the initialization + */ +int xmlInitializeDict(void) { + return(0); +} + +/** + * __xmlInitializeDict: + * + * This function is not public + * Do the dictionary mutex initialization. + * this function is not thread safe, initialization should + * normally be done once at setup when called from xmlOnceInit() + * we may also land in this code if thread support is not compiled in + * + * Returns 0 if initialization was already done, and 1 if that + * call led to the initialization + */ +int __xmlInitializeDict(void) { + if (xmlDictInitialized) + return(1); + + if ((xmlDictMutex = xmlNewRMutex()) == NULL) + return(0); + xmlRMutexLock(xmlDictMutex); + +#ifdef DICT_RANDOMIZATION +#ifdef HAVE_RAND_R + rand_seed = time(NULL); + rand_r(& rand_seed); +#else + srand(time(NULL)); +#endif +#endif + xmlDictInitialized = 1; + xmlRMutexUnlock(xmlDictMutex); + return(1); +} + +#ifdef DICT_RANDOMIZATION +int __xmlRandom(void) { + int ret; + + if (xmlDictInitialized == 0) + __xmlInitializeDict(); + + xmlRMutexLock(xmlDictMutex); +#ifdef HAVE_RAND_R + ret = rand_r(& rand_seed); +#else + ret = rand(); +#endif + xmlRMutexUnlock(xmlDictMutex); + return(ret); +} +#endif + +/** + * xmlDictCleanup: + * + * Free the dictionary mutex. Do not call unless sure the library + * is not in use anymore ! + */ +void +xmlDictCleanup(void) { + if (!xmlDictInitialized) + return; + + xmlFreeRMutex(xmlDictMutex); + + xmlDictInitialized = 0; +} + +/* + * xmlDictAddString: + * @dict: the dictionnary + * @name: the name of the userdata + * @len: the length of the name + * + * Add the string to the array[s] + * + * Returns the pointer of the local string, or NULL in case of error. + */ +static const xmlChar * +xmlDictAddString(xmlDictPtr dict, const xmlChar *name, unsigned int namelen) { + xmlDictStringsPtr pool; + const xmlChar *ret; + size_t size = 0; /* + sizeof(_xmlDictStrings) == 1024 */ + size_t limit = 0; + +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "-"); +#endif + pool = dict->strings; + while (pool != NULL) { + if (pool->end - pool->free > namelen) + goto found_pool; + if (pool->size > size) size = pool->size; + limit += pool->size; + pool = pool->next; + } + /* + * Not found, need to allocate + */ + if (pool == NULL) { + if ((dict->limit > 0) && (limit > dict->limit)) { + return(NULL); + } + + if (size == 0) size = 1000; + else size *= 4; /* exponential growth */ + if (size < 4 * namelen) + size = 4 * namelen; /* just in case ! */ + pool = (xmlDictStringsPtr) xmlMalloc(sizeof(xmlDictStrings) + size); + if (pool == NULL) + return(NULL); + pool->size = size; + pool->nbStrings = 0; + pool->free = &pool->array[0]; + pool->end = &pool->array[size]; + pool->next = dict->strings; + dict->strings = pool; +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "+"); +#endif + } +found_pool: + ret = pool->free; + memcpy(pool->free, name, namelen); + pool->free += namelen; + *(pool->free++) = 0; + pool->nbStrings++; + return(ret); +} + +/* + * xmlDictAddQString: + * @dict: the dictionnary + * @prefix: the prefix of the userdata + * @plen: the prefix length + * @name: the name of the userdata + * @len: the length of the name + * + * Add the QName to the array[s] + * + * Returns the pointer of the local string, or NULL in case of error. + */ +static const xmlChar * +xmlDictAddQString(xmlDictPtr dict, const xmlChar *prefix, unsigned int plen, + const xmlChar *name, unsigned int namelen) +{ + xmlDictStringsPtr pool; + const xmlChar *ret; + size_t size = 0; /* + sizeof(_xmlDictStrings) == 1024 */ + size_t limit = 0; + + if (prefix == NULL) return(xmlDictAddString(dict, name, namelen)); + +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "="); +#endif + pool = dict->strings; + while (pool != NULL) { + if (pool->end - pool->free > namelen + plen + 1) + goto found_pool; + if (pool->size > size) size = pool->size; + limit += pool->size; + pool = pool->next; + } + /* + * Not found, need to allocate + */ + if (pool == NULL) { + if ((dict->limit > 0) && (limit > dict->limit)) { + return(NULL); + } + + if (size == 0) size = 1000; + 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); + if (pool == NULL) + return(NULL); + pool->size = size; + pool->nbStrings = 0; + pool->free = &pool->array[0]; + pool->end = &pool->array[size]; + pool->next = dict->strings; + dict->strings = pool; +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "+"); +#endif + } +found_pool: + ret = pool->free; + memcpy(pool->free, prefix, plen); + pool->free += plen; + *(pool->free++) = ':'; + memcpy(pool->free, name, namelen); + pool->free += namelen; + *(pool->free++) = 0; + pool->nbStrings++; + return(ret); +} + +#ifdef WITH_BIG_KEY +/* + * xmlDictComputeBigKey: + * + * Calculate a hash key using a good hash function that works well for + * larger hash table sizes. + * + * Hash function by "One-at-a-Time Hash" see + * http://burtleburtle.net/bob/hash/doobs.html + */ + +static uint32_t +xmlDictComputeBigKey(const xmlChar* data, int namelen, int seed) { + uint32_t hash; + int i; + + if (namelen <= 0 || data == NULL) return(0); + + hash = seed; + + for (i = 0;i < namelen; i++) { + hash += data[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + + return hash; +} + +/* + * xmlDictComputeBigQKey: + * + * Calculate a hash key for two strings using a good hash function + * that works well for larger hash table sizes. + * + * Hash function by "One-at-a-Time Hash" see + * http://burtleburtle.net/bob/hash/doobs.html + * + * Neither of the two strings must be NULL. + */ +static unsigned long +xmlDictComputeBigQKey(const xmlChar *prefix, int plen, + const xmlChar *name, int len, int seed) +{ + uint32_t hash; + int i; + + hash = seed; + + for (i = 0;i < plen; i++) { + hash += prefix[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + hash += ':'; + hash += (hash << 10); + hash ^= (hash >> 6); + + for (i = 0;i < len; i++) { + hash += name[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + + return hash; +} +#endif /* WITH_BIG_KEY */ + +/* + * xmlDictComputeFastKey: + * + * Calculate a hash key using a fast hash function that works well + * for low hash table fill. + */ +static unsigned long +xmlDictComputeFastKey(const xmlChar *name, int namelen, int seed) { + unsigned long value = seed; + + if (name == NULL) return(0); + value = *name; + value <<= 5; + if (namelen > 10) { + value += name[namelen - 1]; + namelen = 10; + } + switch (namelen) { + case 10: value += name[9]; + case 9: value += name[8]; + case 8: value += name[7]; + case 7: value += name[6]; + case 6: value += name[5]; + case 5: value += name[4]; + case 4: value += name[3]; + case 3: value += name[2]; + case 2: value += name[1]; + default: break; + } + return(value); +} + +/* + * xmlDictComputeFastQKey: + * + * Calculate a hash key for two strings using a fast hash function + * that works well for low hash table fill. + * + * Neither of the two strings must be NULL. + */ +static unsigned long +xmlDictComputeFastQKey(const xmlChar *prefix, int plen, + const xmlChar *name, int len, int seed) +{ + unsigned long value = (unsigned long) seed; + + if (plen == 0) + value += 30 * (unsigned long) ':'; + else + value += 30 * (*prefix); + + if (len > 10) { + value += name[len - (plen + 1 + 1)]; + len = 10; + if (plen > 10) + plen = 10; + } + switch (plen) { + case 10: value += prefix[9]; + case 9: value += prefix[8]; + case 8: value += prefix[7]; + case 7: value += prefix[6]; + case 6: value += prefix[5]; + case 5: value += prefix[4]; + case 4: value += prefix[3]; + case 3: value += prefix[2]; + case 2: value += prefix[1]; + case 1: value += prefix[0]; + default: break; + } + len -= plen; + if (len > 0) { + value += (unsigned long) ':'; + len--; + } + switch (len) { + case 10: value += name[9]; + case 9: value += name[8]; + case 8: value += name[7]; + case 7: value += name[6]; + case 6: value += name[5]; + case 5: value += name[4]; + case 4: value += name[3]; + case 3: value += name[2]; + case 2: value += name[1]; + case 1: value += name[0]; + default: break; + } + return(value); +} + +/** + * xmlDictCreate: + * + * Create a new dictionary + * + * Returns the newly created dictionnary, or NULL if an error occured. + */ +xmlDictPtr +xmlDictCreate(void) { + xmlDictPtr dict; + + if (!xmlDictInitialized) + if (!__xmlInitializeDict()) + return(NULL); + +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "C"); +#endif + + dict = 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->strings = NULL; + dict->subdict = NULL; + if (dict->dict) { + memset(dict->dict, 0, MIN_DICT_SIZE * sizeof(xmlDictEntry)); +#ifdef DICT_RANDOMIZATION + dict->seed = __xmlRandom(); +#else + dict->seed = 0; +#endif + return(dict); + } + xmlFree(dict); + } + return(NULL); +} + +/** + * xmlDictCreateSub: + * @sub: an existing dictionnary + * + * Create a new dictionary, inheriting strings from the read-only + * dictionnary @sub. On lookup, strings are first searched in the + * new dictionnary, then in @sub, and if not found are created in the + * new dictionnary. + * + * Returns the newly created dictionnary, or NULL if an error occured. + */ +xmlDictPtr +xmlDictCreateSub(xmlDictPtr sub) { + xmlDictPtr dict = xmlDictCreate(); + + if ((dict != NULL) && (sub != NULL)) { +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "R"); +#endif + dict->seed = sub->seed; + dict->subdict = sub; + xmlDictReference(dict->subdict); + } + return(dict); +} + +/** + * xmlDictReference: + * @dict: the dictionnary + * + * Increment the reference counter of a dictionary + * + * Returns 0 in case of success and -1 in case of error + */ +int +xmlDictReference(xmlDictPtr dict) { + if (!xmlDictInitialized) + if (!__xmlInitializeDict()) + return(-1); + + if (dict == NULL) return -1; + xmlRMutexLock(xmlDictMutex); + dict->ref_counter++; + xmlRMutexUnlock(xmlDictMutex); + return(0); +} + +/** + * xmlDictGrow: + * @dict: the dictionnary + * @size: the new size of the dictionnary + * + * resize the dictionnary + * + * Returns 0 in case of success, -1 in case of failure + */ +static int +xmlDictGrow(xmlDictPtr dict, size_t size) { + unsigned long key, okey; + size_t oldsize, i; + xmlDictEntryPtr iter, next; + struct _xmlDictEntry *olddict; +#ifdef DEBUG_GROW + unsigned long nbElem = 0; +#endif + int ret = 0; + int keep_keys = 1; + + if (dict == NULL) + return(-1); + if (size < 8) + return(-1); + if (size > 8 * 2048) + return(-1); + +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "*"); +#endif + + oldsize = dict->size; + olddict = dict->dict; + if (olddict == NULL) + return(-1); + if (oldsize == MIN_DICT_SIZE) + keep_keys = 0; + + dict->dict = xmlMalloc(size * sizeof(xmlDictEntry)); + if (dict->dict == NULL) { + dict->dict = olddict; + return(-1); + } + memset(dict->dict, 0, size * sizeof(xmlDictEntry)); + dict->size = size; + + /* If the two loops are merged, there would be situations where + a new entry needs to allocated and data copied into it from + the main dict. It is nicer to run through the array twice, first + copying all the elements in the main array (less probability of + allocate) and then the rest, so we only free in the second loop. + */ + for (i = 0; i < oldsize; i++) { + if (olddict[i].valid == 0) + continue; + + if (keep_keys) + okey = olddict[i].okey; + else + okey = xmlDictComputeKey(dict, olddict[i].name, olddict[i].len); + key = okey % dict->size; + + if (dict->dict[key].valid == 0) { + memcpy(&(dict->dict[key]), &(olddict[i]), sizeof(xmlDictEntry)); + dict->dict[key].next = NULL; + dict->dict[key].okey = okey; + } else { + xmlDictEntryPtr entry; + + entry = xmlMalloc(sizeof(xmlDictEntry)); + if (entry != NULL) { + entry->name = olddict[i].name; + entry->len = olddict[i].len; + entry->okey = okey; + entry->next = dict->dict[key].next; + entry->valid = 1; + dict->dict[key].next = entry; + } else { + /* + * we don't have much ways to alert from herei + * result is loosing an entry and unicity garantee + */ + ret = -1; + } + } +#ifdef DEBUG_GROW + nbElem++; +#endif + } + + for (i = 0; i < oldsize; i++) { + iter = olddict[i].next; + while (iter) { + next = iter->next; + + /* + * put back the entry in the new dict + */ + + if (keep_keys) + okey = iter->okey; + else + okey = xmlDictComputeKey(dict, iter->name, iter->len); + key = okey % dict->size; + if (dict->dict[key].valid == 0) { + memcpy(&(dict->dict[key]), iter, sizeof(xmlDictEntry)); + dict->dict[key].next = NULL; + dict->dict[key].valid = 1; + dict->dict[key].okey = okey; + xmlFree(iter); + } else { + iter->next = dict->dict[key].next; + iter->okey = okey; + dict->dict[key].next = iter; + } + +#ifdef DEBUG_GROW + nbElem++; +#endif + + iter = next; + } + } + + xmlFree(olddict); + +#ifdef DEBUG_GROW + xmlGenericError(xmlGenericErrorContext, + "xmlDictGrow : from %lu to %lu, %u elems\n", oldsize, size, nbElem); +#endif + + return(ret); +} + +/** + * xmlDictFree: + * @dict: the dictionnary + * + * Free the hash @dict and its contents. The userdata is + * deallocated with @f if provided. + */ +void +xmlDictFree(xmlDictPtr dict) { + size_t i; + xmlDictEntryPtr iter; + xmlDictEntryPtr next; + int inside_dict = 0; + xmlDictStringsPtr pool, nextp; + + if (dict == NULL) + return; + + if (!xmlDictInitialized) + if (!__xmlInitializeDict()) + return; + + /* decrement the counter, it may be shared by a parser and docs */ + xmlRMutexLock(xmlDictMutex); + dict->ref_counter--; + if (dict->ref_counter > 0) { + xmlRMutexUnlock(xmlDictMutex); + return; + } + + xmlRMutexUnlock(xmlDictMutex); + + if (dict->subdict != NULL) { + xmlDictFree(dict->subdict); + } + + if (dict->dict) { + for(i = 0; ((i < dict->size) && (dict->nbElems > 0)); i++) { + iter = &(dict->dict[i]); + if (iter->valid == 0) + continue; + inside_dict = 1; + while (iter) { + next = iter->next; + if (!inside_dict) + xmlFree(iter); + dict->nbElems--; + inside_dict = 0; + iter = next; + } + } + xmlFree(dict->dict); + } + pool = dict->strings; + while (pool != NULL) { + nextp = pool->next; + xmlFree(pool); + pool = nextp; + } + xmlFree(dict); +} + +/** + * xmlDictLookup: + * @dict: the dictionnary + * @name: the name of the userdata + * @len: the length of the name, if -1 it is recomputed + * + * Add the @name to the dictionnary @dict if not present. + * + * Returns the internal copy of the name or NULL in case of internal error + */ +const xmlChar * +xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) { + unsigned long key, okey, nbi = 0; + xmlDictEntryPtr entry; + xmlDictEntryPtr insert; + const xmlChar *ret; + unsigned int l; + + if ((dict == NULL) || (name == NULL)) + return(NULL); + + if (len < 0) + l = strlen((const char *) name); + else + l = len; + + if (((dict->limit > 0) && (l >= dict->limit)) || + (l > INT_MAX / 2)) + return(NULL); + + /* + * Check for duplicate and insertion location. + */ + okey = xmlDictComputeKey(dict, name, l); + key = okey % dict->size; + if (dict->dict[key].valid == 0) { + insert = NULL; + } else { + for (insert = &(dict->dict[key]); insert->next != NULL; + insert = insert->next) { +#ifdef __GNUC__ + if ((insert->okey == okey) && (insert->len == l)) { + if (!memcmp(insert->name, name, l)) + return(insert->name); + } +#else + if ((insert->okey == okey) && (insert->len == l) && + (!xmlStrncmp(insert->name, name, l))) + return(insert->name); +#endif + nbi++; + } +#ifdef __GNUC__ + if ((insert->okey == okey) && (insert->len == l)) { + if (!memcmp(insert->name, name, l)) + return(insert->name); + } +#else + if ((insert->okey == okey) && (insert->len == l) && + (!xmlStrncmp(insert->name, name, l))) + return(insert->name); +#endif + } + + if (dict->subdict) { + unsigned long skey; + + /* we cannot always reuse the same okey for the subdict */ + if (((dict->size == MIN_DICT_SIZE) && + (dict->subdict->size != MIN_DICT_SIZE)) || + ((dict->size != MIN_DICT_SIZE) && + (dict->subdict->size == MIN_DICT_SIZE))) + skey = xmlDictComputeKey(dict->subdict, name, l); + else + skey = okey; + + key = skey % dict->subdict->size; + if (dict->subdict->dict[key].valid != 0) { + xmlDictEntryPtr tmp; + + for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL; + tmp = tmp->next) { +#ifdef __GNUC__ + if ((tmp->okey == skey) && (tmp->len == l)) { + if (!memcmp(tmp->name, name, l)) + return(tmp->name); + } +#else + if ((tmp->okey == skey) && (tmp->len == l) && + (!xmlStrncmp(tmp->name, name, l))) + return(tmp->name); +#endif + nbi++; + } +#ifdef __GNUC__ + if ((tmp->okey == skey) && (tmp->len == l)) { + if (!memcmp(tmp->name, name, l)) + return(tmp->name); + } +#else + if ((tmp->okey == skey) && (tmp->len == l) && + (!xmlStrncmp(tmp->name, name, l))) + return(tmp->name); +#endif + } + key = okey % dict->size; + } + + ret = xmlDictAddString(dict, name, l); + if (ret == NULL) + return(NULL); + if (insert == NULL) { + entry = &(dict->dict[key]); + } else { + entry = xmlMalloc(sizeof(xmlDictEntry)); + if (entry == NULL) + return(NULL); + } + entry->name = ret; + entry->len = l; + entry->next = NULL; + entry->valid = 1; + entry->okey = okey; + + + if (insert != NULL) + insert->next = entry; + + dict->nbElems++; + + if ((nbi > MAX_HASH_LEN) && + (dict->size <= ((MAX_DICT_HASH / 2) / MAX_HASH_LEN))) { + if (xmlDictGrow(dict, MAX_HASH_LEN * 2 * dict->size) != 0) + return(NULL); + } + /* Note that entry may have been freed at this point by xmlDictGrow */ + + return(ret); +} + +/** + * xmlDictExists: + * @dict: the dictionnary + * @name: the name of the userdata + * @len: the length of the name, if -1 it is recomputed + * + * Check if the @name exists in the dictionnary @dict. + * + * Returns the internal copy of the name or NULL if not found. + */ +const xmlChar * +xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) { + unsigned long key, okey, nbi = 0; + xmlDictEntryPtr insert; + unsigned int l; + + if ((dict == NULL) || (name == NULL)) + return(NULL); + + if (len < 0) + l = strlen((const char *) name); + else + l = len; + if (((dict->limit > 0) && (l >= dict->limit)) || + (l > INT_MAX / 2)) + return(NULL); + + /* + * Check for duplicate and insertion location. + */ + okey = xmlDictComputeKey(dict, name, l); + key = okey % dict->size; + if (dict->dict[key].valid == 0) { + insert = NULL; + } else { + for (insert = &(dict->dict[key]); insert->next != NULL; + insert = insert->next) { +#ifdef __GNUC__ + if ((insert->okey == okey) && (insert->len == l)) { + if (!memcmp(insert->name, name, l)) + return(insert->name); + } +#else + if ((insert->okey == okey) && (insert->len == l) && + (!xmlStrncmp(insert->name, name, l))) + return(insert->name); +#endif + nbi++; + } +#ifdef __GNUC__ + if ((insert->okey == okey) && (insert->len == l)) { + if (!memcmp(insert->name, name, l)) + return(insert->name); + } +#else + if ((insert->okey == okey) && (insert->len == l) && + (!xmlStrncmp(insert->name, name, l))) + return(insert->name); +#endif + } + + if (dict->subdict) { + unsigned long skey; + + /* we cannot always reuse the same okey for the subdict */ + if (((dict->size == MIN_DICT_SIZE) && + (dict->subdict->size != MIN_DICT_SIZE)) || + ((dict->size != MIN_DICT_SIZE) && + (dict->subdict->size == MIN_DICT_SIZE))) + skey = xmlDictComputeKey(dict->subdict, name, l); + else + skey = okey; + + key = skey % dict->subdict->size; + if (dict->subdict->dict[key].valid != 0) { + xmlDictEntryPtr tmp; + + for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL; + tmp = tmp->next) { +#ifdef __GNUC__ + if ((tmp->okey == skey) && (tmp->len == l)) { + if (!memcmp(tmp->name, name, l)) + return(tmp->name); + } +#else + if ((tmp->okey == skey) && (tmp->len == l) && + (!xmlStrncmp(tmp->name, name, l))) + return(tmp->name); +#endif + nbi++; + } +#ifdef __GNUC__ + if ((tmp->okey == skey) && (tmp->len == l)) { + if (!memcmp(tmp->name, name, l)) + return(tmp->name); + } +#else + if ((tmp->okey == skey) && (tmp->len == l) && + (!xmlStrncmp(tmp->name, name, l))) + return(tmp->name); +#endif + } + } + + /* not found */ + return(NULL); +} + +/** + * xmlDictQLookup: + * @dict: the dictionnary + * @prefix: the prefix + * @name: the name + * + * Add the QName @prefix:@name to the hash @dict if not present. + * + * 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) { + unsigned long okey, key, nbi = 0; + xmlDictEntryPtr entry; + xmlDictEntryPtr insert; + const xmlChar *ret; + unsigned int len, plen, l; + + if ((dict == NULL) || (name == NULL)) + return(NULL); + if (prefix == NULL) + return(xmlDictLookup(dict, name, -1)); + + l = len = strlen((const char *) name); + plen = strlen((const char *) prefix); + len += 1 + plen; + + /* + * Check for duplicate and insertion location. + */ + okey = xmlDictComputeQKey(dict, prefix, plen, name, l); + key = okey % dict->size; + if (dict->dict[key].valid == 0) { + insert = NULL; + } else { + for (insert = &(dict->dict[key]); insert->next != NULL; + insert = insert->next) { + if ((insert->okey == okey) && (insert->len == len) && + (xmlStrQEqual(prefix, name, insert->name))) + return(insert->name); + nbi++; + } + if ((insert->okey == okey) && (insert->len == len) && + (xmlStrQEqual(prefix, name, insert->name))) + return(insert->name); + } + + if (dict->subdict) { + unsigned long skey; + + /* we cannot always reuse the same okey for the subdict */ + if (((dict->size == MIN_DICT_SIZE) && + (dict->subdict->size != MIN_DICT_SIZE)) || + ((dict->size != MIN_DICT_SIZE) && + (dict->subdict->size == MIN_DICT_SIZE))) + skey = xmlDictComputeQKey(dict->subdict, prefix, plen, name, l); + else + skey = okey; + + key = skey % dict->subdict->size; + if (dict->subdict->dict[key].valid != 0) { + xmlDictEntryPtr tmp; + for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL; + tmp = tmp->next) { + if ((tmp->okey == skey) && (tmp->len == len) && + (xmlStrQEqual(prefix, name, tmp->name))) + return(tmp->name); + nbi++; + } + if ((tmp->okey == skey) && (tmp->len == len) && + (xmlStrQEqual(prefix, name, tmp->name))) + return(tmp->name); + } + key = okey % dict->size; + } + + ret = xmlDictAddQString(dict, prefix, plen, name, l); + if (ret == NULL) + return(NULL); + if (insert == NULL) { + entry = &(dict->dict[key]); + } else { + entry = xmlMalloc(sizeof(xmlDictEntry)); + if (entry == NULL) + return(NULL); + } + entry->name = ret; + entry->len = len; + entry->next = NULL; + entry->valid = 1; + entry->okey = okey; + + if (insert != NULL) + insert->next = entry; + + dict->nbElems++; + + if ((nbi > MAX_HASH_LEN) && + (dict->size <= ((MAX_DICT_HASH / 2) / MAX_HASH_LEN))) + xmlDictGrow(dict, MAX_HASH_LEN * 2 * dict->size); + /* Note that entry may have been freed at this point by xmlDictGrow */ + + return(ret); +} + +/** + * xmlDictOwns: + * @dict: the dictionnary + * @str: the string + * + * check if a string is owned by the disctionary + * + * Returns 1 if true, 0 if false and -1 in case of error + * -1 in case of error + */ +int +xmlDictOwns(xmlDictPtr dict, const xmlChar *str) { + xmlDictStringsPtr pool; + + if ((dict == NULL) || (str == NULL)) + return(-1); + pool = dict->strings; + while (pool != NULL) { + if ((str >= &pool->array[0]) && (str <= pool->free)) + return(1); + pool = pool->next; + } + if (dict->subdict) + return(xmlDictOwns(dict->subdict, str)); + return(0); +} + +/** + * xmlDictSize: + * @dict: the dictionnary + * + * Query the number of elements installed in the hash @dict. + * + * Returns the number of elements in the dictionnary or + * -1 in case of error + */ +int +xmlDictSize(xmlDictPtr dict) { + if (dict == NULL) + return(-1); + if (dict->subdict) + return(dict->nbElems + dict->subdict->nbElems); + return(dict->nbElems); +} + +/** + * xmlDictSetLimit: + * @dict: the dictionnary + * @limit: the limit in bytes + * + * Set a size limit for the dictionary + * Added in 2.9.0 + * + * Returns the previous limit of the dictionary or 0 + */ +size_t +xmlDictSetLimit(xmlDictPtr dict, size_t limit) { + size_t ret; + + if (dict == NULL) + return(0); + ret = dict->limit; + dict->limit = limit; + return(ret); +} + +/** + * xmlDictGetUsage: + * @dict: the dictionnary + * + * Get how much memory is used by a dictionary for strings + * Added in 2.9.0 + * + * Returns the amount of strings allocated + */ +size_t +xmlDictGetUsage(xmlDictPtr dict) { + xmlDictStringsPtr pool; + size_t limit = 0; + + if (dict == NULL) + return(0); + pool = dict->strings; + while (pool != NULL) { + limit += pool->size; + pool = pool->next; + } + return(limit); +} + +#define bottom_dict +#include "elfgcchack.h" http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/e181189e/DocFormats/platform/3rdparty/libxml2-2.9.2/doc/APIchunk0.html ---------------------------------------------------------------------- diff --git a/DocFormats/platform/3rdparty/libxml2-2.9.2/doc/APIchunk0.html b/DocFormats/platform/3rdparty/libxml2-2.9.2/doc/APIchunk0.html new file mode 100644 index 0000000..c90e042 --- /dev/null +++ b/DocFormats/platform/3rdparty/libxml2-2.9.2/doc/APIchunk0.html @@ -0,0 +1,301 @@ + + +API Alphabetic Index A-B for libxml2
Action against software patentsGnome2 LogoW3C LogoRed Hat Logo
Made with Libxml2 Logo

The XML C parser and toolkit of Gnome

API Alphabetic In dex A-B for libxml2

Developer Menu
API Indexes
Related links

A-B +C-C +D-E +F-I +J-N +O-P +Q-R +S-S +T-U +V-X +Y-a +b-b +c-c +d-d +e-e +f-f +g-h +i-i +j-l +m-m +n-n +o-o +p-p +q-r +s-s +t-t +u-v +w-w +x-x +y-z +

Letter A:

A-Z
xmlCheckLanguageID
+
A-Za-z
xmlParseEncName
+
A-Za-z0-9
xmlParseEncName
+
ABC
xmlXPathTranslateFunction
+
ABI
_xmlError
+
ALL
xmlAutomataNewAllTrans
+
ANY
xmlIsMixedElement
+xmlParseElementContentDecl
+
APIs
LIBXML_LEGACY_ENABLED
+xmlSchemaValidateSetFilename
+
ARRAY
xmlStrlen
+xmlUTF8Strsize
+
ASCII
UTF8ToHtml
+docbEncodeEntities
+htmlEncodeEntities
+xmlAddEncodingAlias
+xmlDelEncodingAlias
+xmlEncodeEntitiesReentrant
+xmlGetEncodingAlias
+xmlModuleOpen
+xmlModuleSymbol
+xmlNewCharEncodingHandler
+xmlParseCharEncoding
+
ATTLIST
xmlTextWriterStartDTDAttlist
+xmlTextWriterStartDTDEntity
+xmlTextWriterWriteDTDAttlist
+xmlTextWriterWriteFormatDTDAttlist
+xmlTextWriterWriteVFormatDTDAttlist
+
ATTRIBUTE
xmlAddChild
+xmlAddNextSibling
+xmlAddPrevSibling
+
Absolute
xmlBuildURI
+
Accessor
xmlSchemaGetValType
+xmlSchemaValueGetAsBoolean
+xmlSchemaValueGetAsString
+xmlSchemaValueGetNext
+
Activation
xmlTextReaderRelaxNGSetSchema
+xmlTextReaderRelaxNGValidate
+xmlTextReaderRelaxNGValidateCtxt
+xmlTextReaderSchemaValidate
+xmlTextReaderSchemaValidateCtxt
+xmlTextReaderSetSchema
+
Actually
XML_SCHEMAS_TYPE_VARIETY_ABSENT
+
Add
xmlACatalogAdd
+xmlAddChild
+xmlAddChildList
+xmlAddNextSibling
+xmlAddPrevSibling
+xmlAddSibling
+xmlBufferAdd
+xmlBufferAddHead
+xmlCatalogAdd
+xmlCatalogAddLocal
+xmlDictLookup
+xmlDictQLookup
+xmlHashAddEntry
+xmlHashAddEntry2
+xmlHashAddEntry3
+xmlHashUpdateEntry
+xmlHashUpdateEntry2
+xmlHashUpdateEntry3
+
Added
xmlDictGetUsage
+xmlDictSetLimit
+
Additional
_htmlElemDesc
+xmlCleanupGlobals
+xmlInitGlobals
+
AegeanNumbers
xmlUCSIsAegeanNumbers
+
All
_xmlSchema
+_xmlSchemaType
+xmlNanoFTPGet
+xmlNanoFTPList
+xmlParseAttValue
+xmlTextWriterEndDocument
+
Allocate
htmlNewParserCtxt
+xmlNanoFTPNewCtxt
+xmlNewDocElementContent
+xmlNewElementContent
+xmlNewParserCtxt
+xmlNewValidCtxt
+xmlSchemaNewFacet
+xmlSchemaNewNOTATIONValue
+xmlSchemaNewQNameValue
+xmlSchemaNewStringValue
+
Allocates
xmlDOMWrapNewCtxt
+
Allows
xmlCatalogSetDefaultPrefer
+xmlSchemaValidateSetLocator
+
AlphabeticPresentationForms
xmlUCSIsAlphabeticPresentationForms
+
Also
xmlCheckUTF8
+xmlParseAttribute
+xmlValidCtxtNormalizeAttributeValue
+
Always
IS_COMBINING_CH
+
Append
xmlBufferCCat
+xmlBufferCat
+xmlNodeAddContent
+xmlNodeAddContentLen
+
Appendix
xmlRegexpCompile
+
Appends
xmlSchemaValueAppend
+
Applies
htmlCtxtUseOptions
+xmlCtxtUseOptions
+xmlNormalizeURIPath
+xmlXPathCompiledEvalToBoolean
+
Apply
XML_SCHEMAS_ANYATTR_STRICT
+XML_SCHEMAS_ANY_STRICT
+
Arabic
xmlUCSIsArabic
+
ArabicPresentationForms-A
xmlUCSIsArabicPresentationFormsA
+
ArabicPresentationForms-B
xmlUCSIsArabicPresentationFormsB
+
Armenian
xmlUCSIsArmenian
+
Array
_xmlXPathContext
+
Arrows
xmlUCSIsArrows
+
Associate
xmlSetNs
+
Att
xmlParseStartTag
+
AttDef
xmlParseAttributeListDecl
+
AttType
xmlParseAttributeListDecl
+xmlParseAttributeType
+
AttValue
htmlParseElement
+xmlParseAttValue
+xmlParseAttribute
+xmlParseDefaultDecl
+
AttlistDecl
xmlParseAttributeListDecl
+xmlParseMarkupDecl
+
Attribute
_xmlAttribute
+htmlNodeStatus
+htmlParseElement
+xmlParseAttribute
+xmlParseAttributeListDecl
+xmlParseAttributeType
+xmlParseDefaultDecl
+xmlParseStartTag
+xmlTextReaderIsDefault
+xmlTextReaderMoveToElement
+xmlValidateAttributeDecl
+xmlValidateOneAttribute
+xmlValidateOneElement
+xmlValidateOneNamespace
+
Attribute-Value
xmlParseAttValue
+
Attributes
_htmlElemDesc
+xmlParseNotationType
+xmlValidateOneAttribute
+xmlValidateOneNamespace
+xmlXPtrBuildNodeList
+
Automatic
docbCreateFileParserCtxt
+docbParseFile
+docbSAXParseFile
+htmlCreateFileParserCtxt
+htmlParseFile
+htmlSAXParseFile
+xmlCreateEntityParserCtxt
+xmlCreateFileParserCtxt
+xmlCreateURLParserCtxt
+xmlOutputBufferCreateFilename
+xmlParseFile
+xmlParserInputBufferCreateFilename
+xmlRecoverFile
+xmlSAXParseFile
+xmlSAXParseFileWithData
+xmlSAXUserParseFile
+
Automatically
xmlIsBaseCharQ
+xmlIsBaseChar_ch
+xmlIsBlankQ
+xmlIsBlank_ch
+xmlIsCharQ
+xmlIsChar_ch
+xmlIsCombiningQ
+xmlIsDigitQ
+xmlIsDigit_ch
+xmlIsExtenderQ
+xmlIsExtender_ch
+xmlIsIdeographicQ
+xmlIsPubidCharQ
+xmlIsPubidChar_ch
+

Letter B:

BASE
xmlNodeGetBase
+
BAr
xmlXPathTranslateFunction
+
BOM
xmlCharEncOutFunc
+
Balanced
xmlParseBalancedChunkMemory
+xmlParseBalancedChunkMemoryRecover
+xmlParseEntity
+xmlParseInNodeContext
+xmlSAXParseEntity
+
Base
_xmlParserInput
+_xmlSchemaType
+xmlNodeGetBase
+
BaseChar
IS_BASECHAR
+IS_LETTER
+xmlIsLetter
+
Based
xmlExpExpDerive
+xmlXPathIsInf
+xmlXPathIsNaN
+
BasicLatin
xmlUCSIsBasicLatin
+
Basically
xmlValidateDtd
+
Before
xmlParseAttValue
+
Behaves
IS_CHAR_CH
+IS_DIGIT_CH
+IS_EXTENDER_CH
+
Behaviour
IS_BLANK_CH
+
Bengali
xmlUCSIsBengali
+
Best
xmlTextReaderGetRemainder
+
BinHex
xmlTextWriterWriteBinHex
+
Bit
XML_COMPLETE_ATTRS
+XML_DETECT_IDS
+XML_SKIP_IDS
+
BlockElements
xmlUCSIsBlockElements
+
Blocks
xmlStopParser
+
Bopomofo
xmlUCSIsBopomofo
+
BopomofoExtended
xmlUCSIsBopomofoExtended
+
Both
XML_SUBSTITUTE_BOTH
+xmlStreamPush
+xmlStreamPushAttr
+xmlStreamPushNode
+
BoxDrawing
xmlUCSIsBoxDrawing
+
BraillePatterns
xmlUCSIsBraillePatterns
+
Brzozowski
xmlExpExpDerive
+xmlExpStringDerive
+
Buffer
xmlIOParseDTD
+
Bugs:
_htmlElemDesc
+
Buhid
xmlUCSIsBuhid
+
Build
xmlCopyAttributeTable
+xmlCopyDocElementContent
+xmlCopyElementContent
+xmlCopyElementTable
+xmlCopyEntitiesTable
+xmlCopyNotationTable
+xmlGetNodePath
+xmlNodeListGetString
+xmlRegNewExecCtxt
+xmlValidBuildContentModel
+xmlValidGetPotentialChildren
+xmlXPtrBuildNodeList
+
Builds
xmlBuildQName
+xmlNodeListGetRawString
+
But
xmlValidateNotationDecl
+
ByzantineMusicalSymbols
xmlUCSIsByzantineMusicalSymbols
+

A-B +C-C +D-E +F-I +J-N +O-P +Q-R +S-S +T-U +V-X +Y-a +b-b +c-c +d-d +e-e +f-f +g-h +i-i +j-l +m-m +n-n +o-o +p-p +q-r +s-s +t-t +u-v +w-w +x-x +y-z +

Daniel Veillard