#ifndef XmlParse_INCLUDED
#define XmlParse_INCLUDED 1
+#include <stdlib.h>
+
#ifdef __cplusplus
extern "C" {
#endif
-#ifndef XMLPARSEAPI
-#define XMLPARSEAPI /* as nothing */
-#endif
-
typedef void *XML_Parser;
-#ifdef XML_UNICODE_WCHAR_T
-
-/* XML_UNICODE_WCHAR_T will work only if sizeof(wchar_t) == 2 and wchar_t
-uses Unicode. */
-/* Information is UTF-16 encoded as wchar_ts */
-
-#ifndef XML_UNICODE
-#define XML_UNICODE
-#endif
-
-#include <stddef.h>
-typedef wchar_t XML_Char;
-typedef wchar_t XML_LChar;
-
-#else /* not XML_UNICODE_WCHAR_T */
-
-#ifdef XML_UNICODE
-
-/* Information is UTF-16 encoded as unsigned shorts */
-typedef unsigned short XML_Char;
-typedef char XML_LChar;
-
-#else /* not XML_UNICODE */
-
/* Information is UTF-8 encoded. */
typedef char XML_Char;
typedef char XML_LChar;
-#endif /* not XML_UNICODE */
-
-#endif /* not XML_UNICODE_WCHAR_T */
-
enum XML_Content_Type {
XML_CTYPE_EMPTY = 1,
XML_CTYPE_ANY,
/* This is called for an element declaration. See above for
description of the model argument. It's the caller's responsibility
- to free model when finished with it by calling XML_ContentFree.
+ to free model when finished with it.
*/
typedef void (*XML_ElementDeclHandler) (void *userData,
const XML_Char *name,
XML_Content *model);
-void XMLPARSEAPI
+void
XML_SetElementDeclHandler(XML_Parser parser,
XML_ElementDeclHandler eldecl);
-
-void XMLPARSEAPI
-XML_ContentFree(XML_Content *content);
-
/*
The Attlist declaration handler is called for *each* attribute. So
a single Attlist declaration with multiple attributes declared will
const XML_Char *dflt,
int isrequired);
-void XMLPARSEAPI
+void
XML_SetAttlistDeclHandler(XML_Parser parser,
XML_AttlistDeclHandler attdecl);
const XML_Char *encoding,
int standalone);
-
-
-void XMLPARSEAPI
+void
XML_SetXmlDeclHandler(XML_Parser parser,
XML_XmlDeclHandler xmldecl);
+typedef struct {
+ void *(*malloc_fcn)(size_t size);
+ void *(*realloc_fcn)(void *ptr, size_t size);
+ void (*free_fcn)(void *ptr);
+} XML_Memory_Handling_Suite;
+
/* Constructs a new parser; encoding is the encoding specified by the external
protocol or null if there is none specified. */
-XML_Parser XMLPARSEAPI
+XML_Parser
XML_ParserCreate(const XML_Char *encoding);
/* Constructs a new parser and namespace processor. Element type names
separator. When a namespace is not declared, the name and prefix will be
passed through without expansion. */
-XML_Parser XMLPARSEAPI
+XML_Parser
XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
+/* Constructs a new parser using the memory management suit referred to
+ by memsuite. If memsuite is NULL, then use the standard library memory
+ suite. If namespaceSeparator is non-NULL it creates a parser with
+ namespace processing as described above. The character pointed at
+ will serve as the namespace separator.
+
+ All further memory operations used for the created parser will come from
+ the given suite.
+*/
+
+XML_Parser
+XML_ParserCreate_MM(const XML_Char *encoding,
+ const XML_Memory_Handling_Suite *memsuite,
+ const XML_Char *namespaceSeparator);
+
/* atts is array of name/value pairs, terminated by 0;
names and values are 0 terminated. */
const XML_Char *publicId,
const XML_Char *notationName);
-void XMLPARSEAPI
+void
XML_SetEntityDeclHandler(XML_Parser parser,
XML_EntityDeclHandler handler);
const XML_Char *name,
XML_Encoding *info);
-void XMLPARSEAPI
+void
XML_SetElementHandler(XML_Parser parser,
XML_StartElementHandler start,
XML_EndElementHandler end);
-void XMLPARSEAPI
+void
XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler);
-void XMLPARSEAPI
+void
XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler);
-void XMLPARSEAPI
+void
XML_SetCharacterDataHandler(XML_Parser parser,
XML_CharacterDataHandler handler);
-void XMLPARSEAPI
+void
XML_SetProcessingInstructionHandler(XML_Parser parser,
XML_ProcessingInstructionHandler handler);
-void XMLPARSEAPI
+void
XML_SetCommentHandler(XML_Parser parser,
XML_CommentHandler handler);
-void XMLPARSEAPI
+void
XML_SetCdataSectionHandler(XML_Parser parser,
XML_StartCdataSectionHandler start,
XML_EndCdataSectionHandler end);
-void XMLPARSEAPI
+void
XML_SetStartCdataSectionHandler(XML_Parser parser,
XML_StartCdataSectionHandler start);
-void XMLPARSEAPI
+void
XML_SetEndCdataSectionHandler(XML_Parser parser,
XML_EndCdataSectionHandler end);
/* This sets the default handler and also inhibits expansion of internal entities.
The entity reference will be passed to the default handler. */
-void XMLPARSEAPI
+void
XML_SetDefaultHandler(XML_Parser parser,
XML_DefaultHandler handler);
/* This sets the default handler but does not inhibit expansion of internal entities.
The entity reference will not be passed to the default handler. */
-void XMLPARSEAPI
+void
XML_SetDefaultHandlerExpand(XML_Parser parser,
XML_DefaultHandler handler);
-void XMLPARSEAPI
+void
XML_SetDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start,
XML_EndDoctypeDeclHandler end);
-void XMLPARSEAPI
+void
XML_SetStartDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start);
-void XMLPARSEAPI
+void
XML_SetEndDoctypeDeclHandler(XML_Parser parser,
XML_EndDoctypeDeclHandler end);
-void XMLPARSEAPI
+void
XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
XML_UnparsedEntityDeclHandler handler);
-void XMLPARSEAPI
+void
XML_SetNotationDeclHandler(XML_Parser parser,
XML_NotationDeclHandler handler);
-void XMLPARSEAPI
+void
XML_SetNamespaceDeclHandler(XML_Parser parser,
XML_StartNamespaceDeclHandler start,
XML_EndNamespaceDeclHandler end);
-void XMLPARSEAPI
+void
XML_SetStartNamespaceDeclHandler(XML_Parser parser,
XML_StartNamespaceDeclHandler start);
-void XMLPARSEAPI
+void
XML_SetEndNamespaceDeclHandler(XML_Parser parser,
XML_EndNamespaceDeclHandler end);
-void XMLPARSEAPI
+void
XML_SetNotStandaloneHandler(XML_Parser parser,
XML_NotStandaloneHandler handler);
-void XMLPARSEAPI
+void
XML_SetExternalEntityRefHandler(XML_Parser parser,
XML_ExternalEntityRefHandler handler);
/* If a non-null value for arg is specified here, then it will be passed
as the first argument to the external entity ref handler instead
of the parser object. */
-void XMLPARSEAPI
+void
XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg);
-void XMLPARSEAPI
+void
XML_SetUnknownEncodingHandler(XML_Parser parser,
XML_UnknownEncodingHandler handler,
void *encodingHandlerData);
/* This can be called within a handler for a start element, end element,
processing instruction or character data. It causes the corresponding
markup to be passed to the default handler. */
-void XMLPARSEAPI XML_DefaultCurrent(XML_Parser parser);
+void XML_DefaultCurrent(XML_Parser parser);
/* This value is passed as the userData argument to callbacks. */
-void XMLPARSEAPI
+void
XML_SetUserData(XML_Parser parser, void *userData);
/* Returns the last value set by XML_SetUserData or null. */
to XML_ParserCreate. It must not be called after XML_Parse
or XML_ParseBuffer. */
-int XMLPARSEAPI
+int
XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
/* If this function is called, then the parser will be passed
as the first argument to callbacks instead of userData.
The userData will still be accessible using XML_GetUserData. */
-void XMLPARSEAPI
+void
XML_UseParserAsHandlerArg(XML_Parser parser);
/* Sets the base to be used for resolving relative URIs in system identifiers in
and XML_UnparsedEntityDeclHandler. The base argument will be copied.
Returns zero if out of memory, non-zero otherwise. */
-int XMLPARSEAPI
+int
XML_SetBase(XML_Parser parser, const XML_Char *base);
-const XML_Char XMLPARSEAPI *
+const XML_Char *
XML_GetBase(XML_Parser parser);
/* Returns the number of the attribute/value pairs passed in last call
this correspondds to an index into the atts array passed to the
XML_StartElementHandler. */
-int XMLPARSEAPI XML_GetSpecifiedAttributeCount(XML_Parser parser);
+int XML_GetSpecifiedAttributeCount(XML_Parser parser);
/* Returns the index of the ID attribute passed in the last call to
XML_StartElementHandler, or -1 if there is no ID attribute. Each
attribute/value pair counts as 2; thus this correspondds to an index
into the atts array passed to the XML_StartElementHandler. */
-int XMLPARSEAPI XML_GetIdAttributeIndex(XML_Parser parser);
+int XML_GetIdAttributeIndex(XML_Parser parser);
/* Parses some input. Returns 0 if a fatal error is detected.
The last call to XML_Parse must have isFinal true;
len may be zero for this call (or any other). */
-int XMLPARSEAPI
+int
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
-void XMLPARSEAPI *
+void *
XML_GetBuffer(XML_Parser parser, int len);
-int XMLPARSEAPI
+int
XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
/* Creates an XML_Parser object that can parse an external general entity;
The new parser is completely independent and may safely be used in a separate thread.
The handlers and userData are initialized from the parser argument.
Returns 0 if out of memory. Otherwise returns a new XML_Parser object. */
-XML_Parser XMLPARSEAPI
+XML_Parser
XML_ExternalEntityParserCreate(XML_Parser parser,
const XML_Char *context,
const XML_Char *encoding);
XML_SetParamEntityParsing will return 0 if parsing of parameter
entities is requested; otherwise it will return non-zero. */
-int XMLPARSEAPI
+int
XML_SetParamEntityParsing(XML_Parser parser,
enum XML_ParamEntityParsing parsing);
/* If XML_Parse or XML_ParseBuffer have returned 0, then XML_GetErrorCode
returns information about the error. */
-enum XML_Error XMLPARSEAPI XML_GetErrorCode(XML_Parser parser);
+enum XML_Error XML_GetErrorCode(XML_Parser parser);
/* These functions return information about the current parse location.
They may be called when XML_Parse or XML_ParseBuffer return 0;
some parse event; in this the location is the location of the first
of the sequence of characters that generated the event. */
-int XMLPARSEAPI XML_GetCurrentLineNumber(XML_Parser parser);
-int XMLPARSEAPI XML_GetCurrentColumnNumber(XML_Parser parser);
-long XMLPARSEAPI XML_GetCurrentByteIndex(XML_Parser parser);
+int XML_GetCurrentLineNumber(XML_Parser parser);
+int XML_GetCurrentColumnNumber(XML_Parser parser);
+long XML_GetCurrentByteIndex(XML_Parser parser);
/* Return the number of bytes in the current event.
Returns 0 if the event is in an internal entity. */
-int XMLPARSEAPI XML_GetCurrentByteCount(XML_Parser parser);
+int XML_GetCurrentByteCount(XML_Parser parser);
/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
the integer pointed to by offset to the offset within this buffer
NOTE: The character pointer returned should not be used outside
the handler that makes the call. */
-const char XMLPARSEAPI * XML_GetInputContext(XML_Parser parser,
+const char * XML_GetInputContext(XML_Parser parser,
int *offset,
int *size);
#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
/* Frees memory used by the parser. */
-void XMLPARSEAPI
+void
XML_ParserFree(XML_Parser parser);
/* Returns a string describing the error. */
-const XML_LChar XMLPARSEAPI *XML_ErrorString(int code);
+const XML_LChar *XML_ErrorString(int code);
#ifdef __cplusplus
}
size_t size;
size_t used;
size_t usedLim;
+ XML_Memory_Handling_Suite *mem;
} HASH_TABLE;
typedef struct {
const XML_Char *end;
XML_Char *ptr;
XML_Char *start;
+ XML_Memory_Handling_Suite *mem;
} STRING_POOL;
/* The XML_Char before the name is used to determine whether
TAG_NAME *tagNamePtr, BINDING **bindingsPtr);
static
int addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, const XML_Char *uri, BINDING **bindingsPtr);
+
static int
-defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, int isCdata, int isId, const XML_Char *dfltValue);
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *,
+ int isCdata, int isId, const XML_Char *dfltValue,
+ XML_Parser parser);
+
static enum XML_Error
storeAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,
STRING_POOL *);
static const XML_Char *getContext(XML_Parser parser);
static int setContext(XML_Parser parser, const XML_Char *context);
static void normalizePublicId(XML_Char *s);
-static int dtdInit(DTD *);
-static void dtdDestroy(DTD *);
-static int dtdCopy(DTD *newDtd, const DTD *oldDtd);
-static int copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);
+static int dtdInit(DTD *, XML_Parser parser);
+
+static void dtdDestroy(DTD *, XML_Parser parser);
+
+static int dtdCopy(DTD *newDtd, const DTD *oldDtd, XML_Parser parser);
+
+static int copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *,
+ XML_Parser parser);
+
#ifdef XML_DTD
static void dtdSwap(DTD *, DTD *);
#endif /* XML_DTD */
+
static NAMED *lookup(HASH_TABLE *table, KEY name, size_t createSize);
-static void hashTableInit(HASH_TABLE *);
+
+static void hashTableInit(HASH_TABLE *, XML_Memory_Handling_Suite *ms);
+
static void hashTableDestroy(HASH_TABLE *);
static void hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
static NAMED *hashTableIterNext(HASH_TABLE_ITER *);
-static void poolInit(STRING_POOL *);
+static void poolInit(STRING_POOL *, XML_Memory_Handling_Suite *ms);
static void poolClear(STRING_POOL *);
static void poolDestroy(STRING_POOL *);
static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
const char *ptr, const char *end);
static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
const char *ptr, const char *end);
+
static int poolGrow(STRING_POOL *pool);
+
static int nextScaffoldPart(XML_Parser parser);
static XML_Content *build_model(XML_Parser parser);
void *m_userData;
void *m_handlerArg;
char *m_buffer;
+ XML_Memory_Handling_Suite m_mem;
/* first character to be parsed */
const char *m_bufferPtr;
/* past last character to be parsed */
#endif
} Parser;
+#define MALLOC(s) (((Parser *)parser)->m_mem.malloc_fcn((s)))
+#define REALLOC(p,s) (((Parser *)parser)->m_mem.realloc_fcn((p),(s)))
+#define FREE(p) (((Parser *)parser)->m_mem.free_fcn((p)))
+
#define userData (((Parser *)parser)->m_userData)
#define handlerArg (((Parser *)parser)->m_handlerArg)
#define startElementHandler (((Parser *)parser)->m_startElementHandler)
XML_Parser XML_ParserCreate(const XML_Char *encodingName)
{
- XML_Parser parser = malloc(sizeof(Parser));
+ return XML_ParserCreate_MM(encodingName, NULL, NULL);
+}
+
+XML_Parser XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
+{
+ XML_Char tmp[2];
+ *tmp = nsSep;
+ return XML_ParserCreate_MM(encodingName, NULL, tmp);
+}
+
+XML_Parser
+XML_ParserCreate_MM(const XML_Char *encodingName,
+ const XML_Memory_Handling_Suite *memsuite,
+ const XML_Char *nameSep) {
+
+ XML_Parser parser;
+ static
+ const XML_Char implicitContext[] = {
+ XML_T('x'), XML_T('m'), XML_T('l'), XML_T('='),
+ XML_T('h'), XML_T('t'), XML_T('t'), XML_T('p'), XML_T(':'),
+ XML_T('/'), XML_T('/'), XML_T('w'), XML_T('w'), XML_T('w'),
+ XML_T('.'), XML_T('w'), XML_T('3'),
+ XML_T('.'), XML_T('o'), XML_T('r'), XML_T('g'),
+ XML_T('/'), XML_T('X'), XML_T('M'), XML_T('L'),
+ XML_T('/'), XML_T('1'), XML_T('9'), XML_T('9'), XML_T('8'),
+ XML_T('/'), XML_T('n'), XML_T('a'), XML_T('m'), XML_T('e'),
+ XML_T('s'), XML_T('p'), XML_T('a'), XML_T('c'), XML_T('e'),
+ XML_T('\0')
+ };
+
+
+ if (memsuite) {
+ XML_Memory_Handling_Suite *mtemp;
+ parser = memsuite->malloc_fcn(sizeof(Parser));
+ mtemp = &(((Parser *) parser)->m_mem);
+ mtemp->malloc_fcn = memsuite->malloc_fcn;
+ mtemp->realloc_fcn = memsuite->realloc_fcn;
+ mtemp->free_fcn = memsuite->free_fcn;
+ }
+ else {
+ XML_Memory_Handling_Suite *mtemp;
+ parser = malloc(sizeof(Parser));
+ mtemp = &(((Parser *) parser)->m_mem);
+ mtemp->malloc_fcn = malloc;
+ mtemp->realloc_fcn = realloc;
+ mtemp->free_fcn = free;
+ }
+
if (!parser)
return parser;
processor = prologInitProcessor;
freeBindingList = 0;
inheritedBindings = 0;
attsSize = INIT_ATTS_SIZE;
- atts = malloc(attsSize * sizeof(ATTRIBUTE));
+ atts = MALLOC(attsSize * sizeof(ATTRIBUTE));
nSpecifiedAtts = 0;
- dataBuf = malloc(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
+ dataBuf = MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
groupSize = 0;
groupConnector = 0;
hadExternalDoctype = 0;
paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
#endif
ns = 0;
- poolInit(&tempPool);
- poolInit(&temp2Pool);
+ poolInit(&tempPool, &(((Parser *) parser)->m_mem));
+ poolInit(&temp2Pool, &(((Parser *) parser)->m_mem));
protocolEncodingName = encodingName ? poolCopyString(&tempPool, encodingName) : 0;
curBase = 0;
- if (!dtdInit(&dtd) || !atts || !dataBuf
+ if (!dtdInit(&dtd, parser) || !atts || !dataBuf
|| (encodingName && !protocolEncodingName)) {
XML_ParserFree(parser);
return 0;
}
dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;
- XmlInitEncoding(&initEncoding, &encoding, 0);
- internalEncoding = XmlGetInternalEncoding();
- return parser;
-}
-
-XML_Parser XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
-{
- static
- const XML_Char implicitContext[] = {
- XML_T('x'), XML_T('m'), XML_T('l'), XML_T('='),
- XML_T('h'), XML_T('t'), XML_T('t'), XML_T('p'), XML_T(':'),
- XML_T('/'), XML_T('/'), XML_T('w'), XML_T('w'), XML_T('w'),
- XML_T('.'), XML_T('w'), XML_T('3'),
- XML_T('.'), XML_T('o'), XML_T('r'), XML_T('g'),
- XML_T('/'), XML_T('X'), XML_T('M'), XML_T('L'),
- XML_T('/'), XML_T('1'), XML_T('9'), XML_T('9'), XML_T('8'),
- XML_T('/'), XML_T('n'), XML_T('a'), XML_T('m'), XML_T('e'),
- XML_T('s'), XML_T('p'), XML_T('a'), XML_T('c'), XML_T('e'),
- XML_T('\0')
- };
- XML_Parser parser = XML_ParserCreate(encodingName);
- if (parser) {
+ if (nameSep) {
XmlInitEncodingNS(&initEncoding, &encoding, 0);
ns = 1;
internalEncoding = XmlGetInternalEncodingNS();
- namespaceSeparator = nsSep;
+ namespaceSeparator = *nameSep;
+
+ if (! setContext(parser, implicitContext)) {
+ XML_ParserFree(parser);
+ return 0;
+ }
}
- if (!setContext(parser, implicitContext)) {
- XML_ParserFree(parser);
- return 0;
+ else {
+ XmlInitEncoding(&initEncoding, &encoding, 0);
+ internalEncoding = XmlGetInternalEncoding();
}
+
return parser;
-}
+} /* End XML_ParserCreate_MM */
int XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
{
#ifdef XML_DTD
int oldParamEntityParsing = paramEntityParsing;
#endif
- parser = (ns
- ? XML_ParserCreateNS(encodingName, namespaceSeparator)
- : XML_ParserCreate(encodingName));
+
+ if (ns) {
+ XML_Char tmp[2];
+
+ *tmp = namespaceSeparator;
+ parser = XML_ParserCreate_MM(encodingName, &((Parser *)parser)->m_mem,
+ tmp);
+ }
+ else {
+ parser = XML_ParserCreate_MM(encodingName, &((Parser *)parser)->m_mem,
+ NULL);
+ }
+
if (!parser)
return 0;
+
startElementHandler = oldStartElementHandler;
endElementHandler = oldEndElementHandler;
characterDataHandler = oldCharacterDataHandler;
paramEntityParsing = oldParamEntityParsing;
if (context) {
#endif /* XML_DTD */
- if (!dtdCopy(&dtd, oldDtd) || !setContext(parser, context)) {
+ if (!dtdCopy(&dtd, oldDtd, parser) || !setContext(parser, context)) {
XML_ParserFree(parser);
return 0;
}
}
static
-void destroyBindings(BINDING *bindings)
+void destroyBindings(BINDING *bindings, XML_Parser parser)
{
for (;;) {
BINDING *b = bindings;
if (!b)
break;
bindings = b->nextTagBinding;
- free(b->uri);
- free(b);
+ FREE(b->uri);
+ FREE(b);
}
}
}
p = tagStack;
tagStack = tagStack->parent;
- free(p->buf);
- destroyBindings(p->bindings);
- free(p);
+ FREE(p->buf);
+ destroyBindings(p->bindings, parser);
+ FREE(p);
}
- destroyBindings(freeBindingList);
- destroyBindings(inheritedBindings);
+ destroyBindings(freeBindingList, parser);
+ destroyBindings(inheritedBindings, parser);
poolDestroy(&tempPool);
poolDestroy(&temp2Pool);
#ifdef XML_DTD
dtdSwap(&dtd, &((Parser *)parentParser)->m_dtd);
}
#endif /* XML_DTD */
- dtdDestroy(&dtd);
- free((void *)atts);
+ dtdDestroy(&dtd, parser);
+ FREE((void *)atts);
if (groupConnector)
- free(groupConnector);
+ FREE(groupConnector);
if (buffer)
- free(buffer);
- free(dataBuf);
+ FREE(buffer);
+ FREE(dataBuf);
if (unknownEncodingMem)
- free(unknownEncodingMem);
+ FREE(unknownEncodingMem);
if (unknownEncodingRelease)
unknownEncodingRelease(unknownEncodingData);
- free(parser);
-}
-
-void XML_ContentFree(XML_Content *content)
-{
- free(content);
+ FREE(parser);
}
void XML_UseParserAsHandlerArg(XML_Parser parser)
if (nLeftOver) {
if (buffer == 0 || nLeftOver > bufferLim - buffer) {
/* FIXME avoid integer overflow */
- buffer = buffer == 0 ? malloc(len * 2) : realloc(buffer, len * 2);
+ buffer = buffer == 0 ? MALLOC(len * 2) : REALLOC(buffer, len * 2);
/* FIXME storage leak if realloc fails */
if (!buffer) {
errorCode = XML_ERROR_NO_MEMORY;
do {
bufferSize *= 2;
} while (bufferSize < neededSize);
- newBuf = malloc(bufferSize);
+ newBuf = MALLOC(bufferSize);
if (newBuf == 0) {
errorCode = XML_ERROR_NO_MEMORY;
return 0;
if (keep > XML_CONTEXT_BYTES)
keep = XML_CONTEXT_BYTES;
memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep);
- free(buffer);
+ FREE(buffer);
buffer = newBuf;
bufferEnd = buffer + (bufferEnd - bufferPtr) + keep;
bufferPtr = buffer + keep;
#else
if (bufferPtr) {
memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr);
- free(buffer);
+ FREE(buffer);
}
bufferEnd = newBuf + (bufferEnd - bufferPtr);
bufferPtr = buffer = newBuf;
freeTagList = freeTagList->parent;
}
else {
- tag = malloc(sizeof(TAG));
+ tag = MALLOC(sizeof(TAG));
if (!tag)
return XML_ERROR_NO_MEMORY;
- tag->buf = malloc(INIT_TAG_BUF_SIZE);
+ tag->buf = MALLOC(INIT_TAG_BUF_SIZE);
if (!tag->buf)
return XML_ERROR_NO_MEMORY;
tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
if (tag->rawNameLength + (int)(sizeof(XML_Char) - 1) + (int)sizeof(XML_Char) > tag->bufEnd - tag->buf) {
int bufSize = tag->rawNameLength * 4;
bufSize = ROUND_UP(bufSize, sizeof(XML_Char));
- tag->buf = realloc(tag->buf, bufSize);
+ tag->buf = REALLOC(tag->buf, bufSize);
if (!tag->buf)
return XML_ERROR_NO_MEMORY;
tag->bufEnd = tag->buf + bufSize;
if (fromPtr == rawNameEnd)
break;
bufSize = (tag->bufEnd - tag->buf) << 1;
- tag->buf = realloc(tag->buf, bufSize);
+ tag->buf = REALLOC(tag->buf, bufSize);
if (!tag->buf)
return XML_ERROR_NO_MEMORY;
tag->bufEnd = tag->buf + bufSize;
/* lookup the element type name */
if (tagNamePtr) {
- elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagNamePtr->str, 0);
+ elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagNamePtr->str,0);
if (!elementType) {
tagNamePtr->str = poolCopyString(&dtd.pool, tagNamePtr->str);
if (!tagNamePtr->str)
if (n + nDefaultAtts > attsSize) {
int oldAttsSize = attsSize;
attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
- atts = realloc((void *)atts, attsSize * sizeof(ATTRIBUTE));
+ atts = REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
if (!atts)
return XML_ERROR_NO_MEMORY;
if (n > oldAttsSize)
n = i + binding->uriLen;
if (n > binding->uriAlloc) {
TAG *p;
- XML_Char *uri = malloc((n + EXPAND_SPARE) * sizeof(XML_Char));
+ XML_Char *uri = MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));
if (!uri)
return XML_ERROR_NO_MEMORY;
binding->uriAlloc = n + EXPAND_SPARE;
for (p = tagStack; p; p = p->parent)
if (p->name.str == binding->uri)
p->name.str = uri;
- free(binding->uri);
+ FREE(binding->uri);
binding->uri = uri;
}
memcpy(binding->uri + binding->uriLen, localPart, i * sizeof(XML_Char));
if (freeBindingList) {
b = freeBindingList;
if (len > b->uriAlloc) {
- b->uri = realloc(b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
+ b->uri = REALLOC(b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
if (!b->uri)
return 0;
b->uriAlloc = len + EXPAND_SPARE;
freeBindingList = b->nextTagBinding;
}
else {
- b = malloc(sizeof(BINDING));
+ b = MALLOC(sizeof(BINDING));
if (!b)
return 0;
- b->uri = malloc(sizeof(XML_Char) * (len + EXPAND_SPARE));
+ b->uri = MALLOC(sizeof(XML_Char) * (len + EXPAND_SPARE));
if (!b->uri) {
- free(b);
+ FREE(b);
return 0;
}
b->uriAlloc = len + EXPAND_SPARE;
info.release = 0;
if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName, &info)) {
ENCODING *enc;
- unknownEncodingMem = malloc(XmlSizeOfUnknownEncoding());
+ unknownEncodingMem = MALLOC(XmlSizeOfUnknownEncoding());
if (!unknownEncodingMem) {
if (info.release)
info.release(info.data);
case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
if (dtd.complete
&& !defineAttribute(declElementType, declAttributeId,
- declAttributeIsCdata, declAttributeIsId, 0))
+ declAttributeIsCdata, declAttributeIsId, 0,
+ parser))
return XML_ERROR_NO_MEMORY;
if (attlistDeclHandler && declAttributeType) {
if (*declAttributeType == '('
poolFinish(&dtd.pool);
if (dtd.complete
/* ID attributes aren't allowed to have a default */
- && !defineAttribute(declElementType, declAttributeId, declAttributeIsCdata, 0, attVal))
+ && !defineAttribute(declElementType, declAttributeId, declAttributeIsCdata, 0, attVal, parser))
return XML_ERROR_NO_MEMORY;
if (attlistDeclHandler && declAttributeType) {
if (*declAttributeType == '('
const XML_Char *name = poolStoreString(&dtd.pool, enc, s, next);
if (!name)
return XML_ERROR_NO_MEMORY;
- declEntity = (ENTITY *)lookup(&dtd.paramEntities, name, sizeof(ENTITY));
+ declEntity = (ENTITY *)lookup(&dtd.paramEntities,
+ name, sizeof(ENTITY));
if (!declEntity)
return XML_ERROR_NO_MEMORY;
if (declEntity->name != name) {
case XML_ROLE_GROUP_OPEN:
if (prologState.level >= groupSize) {
if (groupSize) {
- groupConnector = realloc(groupConnector, groupSize *= 2);
+ groupConnector = REALLOC(groupConnector, groupSize *= 2);
if (dtd.scaffIndex)
- dtd.scaffIndex = realloc(dtd.scaffIndex, groupSize * sizeof(int));
+ dtd.scaffIndex = REALLOC(dtd.scaffIndex, groupSize * sizeof(int));
}
else
- groupConnector = malloc(groupSize = 32);
+ groupConnector = MALLOC(groupSize = 32);
if (!groupConnector)
return XML_ERROR_NO_MEMORY;
}
case XML_ROLE_CONTENT_EMPTY:
if (dtd.in_eldecl) {
if (elementDeclHandler) {
- XML_Content * content = (XML_Content *) malloc(sizeof(XML_Content));
+ XML_Content * content = (XML_Content *) MALLOC(sizeof(XML_Content));
if (! content)
return XML_ERROR_NO_MEMORY;
content->quant = XML_CQUANT_NONE;
static int
-defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, int isCdata, int isId, const XML_Char *value)
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, int isCdata,
+ int isId, const XML_Char *value, XML_Parser parser)
{
DEFAULT_ATTRIBUTE *att;
if (value || isId) {
if (type->nDefaultAtts == type->allocDefaultAtts) {
if (type->allocDefaultAtts == 0) {
type->allocDefaultAtts = 8;
- type->defaultAtts = malloc(type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
+ type->defaultAtts = MALLOC(type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
}
else {
type->allocDefaultAtts *= 2;
- type->defaultAtts = realloc(type->defaultAtts,
+ type->defaultAtts = REALLOC(type->defaultAtts,
type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
}
if (!type->defaultAtts)
*p = XML_T('\0');
}
-static int dtdInit(DTD *p)
+static int dtdInit(DTD *p, XML_Parser parser)
{
- poolInit(&(p->pool));
- hashTableInit(&(p->generalEntities));
- hashTableInit(&(p->elementTypes));
- hashTableInit(&(p->attributeIds));
- hashTableInit(&(p->prefixes));
+ XML_Memory_Handling_Suite *ms = &((Parser *) parser)->m_mem;
+ poolInit(&(p->pool), ms);
+ hashTableInit(&(p->generalEntities), ms);
+ hashTableInit(&(p->elementTypes), ms);
+ hashTableInit(&(p->attributeIds), ms);
+ hashTableInit(&(p->prefixes), ms);
p->complete = 1;
p->standalone = 0;
#ifdef XML_DTD
- hashTableInit(&(p->paramEntities));
+ hashTableInit(&(p->paramEntities), ms);
#endif /* XML_DTD */
p->defaultPrefix.name = 0;
p->defaultPrefix.binding = 0;
#endif /* XML_DTD */
-static void dtdDestroy(DTD *p)
+static void dtdDestroy(DTD *p, XML_Parser parser)
{
HASH_TABLE_ITER iter;
hashTableIterInit(&iter, &(p->elementTypes));
if (!e)
break;
if (e->allocDefaultAtts != 0)
- free(e->defaultAtts);
+ FREE(e->defaultAtts);
}
hashTableDestroy(&(p->generalEntities));
#ifdef XML_DTD
hashTableDestroy(&(p->prefixes));
poolDestroy(&(p->pool));
if (p->scaffIndex)
- free(p->scaffIndex);
+ FREE(p->scaffIndex);
if (p->scaffold)
- free(p->scaffold);
+ FREE(p->scaffold);
}
/* Do a deep copy of the DTD. Return 0 for out of memory; non-zero otherwise.
The new DTD has already been initialized. */
-static int dtdCopy(DTD *newDtd, const DTD *oldDtd)
+static int dtdCopy(DTD *newDtd, const DTD *oldDtd, XML_Parser parser)
{
HASH_TABLE_ITER iter;
if (!newE)
return 0;
if (oldE->nDefaultAtts) {
- newE->defaultAtts = (DEFAULT_ATTRIBUTE *)malloc(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
+ newE->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
if (!newE->defaultAtts)
return 0;
}
/* Copy the entity tables. */
if (!copyEntityTable(&(newDtd->generalEntities),
&(newDtd->pool),
- &(oldDtd->generalEntities)))
+ &(oldDtd->generalEntities), parser))
return 0;
#ifdef XML_DTD
if (!copyEntityTable(&(newDtd->paramEntities),
&(newDtd->pool),
- &(oldDtd->paramEntities)))
+ &(oldDtd->paramEntities), parser))
return 0;
#endif /* XML_DTD */
newDtd->scaffIndex = oldDtd->scaffIndex;
return 1;
-}
+} /* End dtdCopy */
static int copyEntityTable(HASH_TABLE *newTable,
STRING_POOL *newPool,
- const HASH_TABLE *oldTable)
+ const HASH_TABLE *oldTable,
+ XML_Parser parser)
{
HASH_TABLE_ITER iter;
const XML_Char *cachedOldBase = 0;
{
size_t i;
if (table->size == 0) {
+ size_t tsize;
+
if (!createSize)
return 0;
- table->v = calloc(INIT_SIZE, sizeof(NAMED *));
+ tsize = INIT_SIZE * sizeof(NAMED *);
+ table->v = table->mem->malloc_fcn(tsize);
if (!table->v)
return 0;
+ memset(table->v, 0, tsize);
table->size = INIT_SIZE;
table->usedLim = INIT_SIZE / 2;
i = hash(name) & (table->size - 1);
if (table->used == table->usedLim) {
/* check for overflow */
size_t newSize = table->size * 2;
- NAMED **newV = calloc(newSize, sizeof(NAMED *));
+ size_t tsize = newSize * sizeof(NAMED *);
+ NAMED **newV = table->mem->malloc_fcn(tsize);
if (!newV)
return 0;
+ memset(newV, 0, tsize);
for (i = 0; i < table->size; i++)
if (table->v[i]) {
size_t j;
;
newV[j] = table->v[i];
}
- free(table->v);
+ table->mem->free_fcn(table->v);
table->v = newV;
table->size = newSize;
table->usedLim = newSize/2;
;
}
}
- table->v[i] = calloc(1, createSize);
+ table->v[i] = table->mem->malloc_fcn(createSize);
if (!table->v[i])
return 0;
+ memset(table->v[i], 0, createSize);
table->v[i]->name = name;
(table->used)++;
return table->v[i];
for (i = 0; i < table->size; i++) {
NAMED *p = table->v[i];
if (p)
- free(p);
+ table->mem->free_fcn(p);
}
if (table->v)
- free(table->v);
+ table->mem->free_fcn(table->v);
}
static
-void hashTableInit(HASH_TABLE *p)
+void hashTableInit(HASH_TABLE *p, XML_Memory_Handling_Suite *ms)
{
p->size = 0;
p->usedLim = 0;
p->used = 0;
p->v = 0;
+ p->mem = ms;
}
static
static
-void poolInit(STRING_POOL *pool)
+void poolInit(STRING_POOL *pool, XML_Memory_Handling_Suite *ms)
{
pool->blocks = 0;
pool->freeBlocks = 0;
pool->start = 0;
pool->ptr = 0;
pool->end = 0;
+ pool->mem = ms;
}
static
BLOCK *p = pool->blocks;
while (p) {
BLOCK *tem = p->next;
- free(p);
+ pool->mem->free_fcn(p);
p = tem;
}
pool->blocks = 0;
p = pool->freeBlocks;
while (p) {
BLOCK *tem = p->next;
- free(p);
+ pool->mem->free_fcn(p);
p = tem;
}
pool->freeBlocks = 0;
}
if (pool->blocks && pool->start == pool->blocks->s) {
int blockSize = (pool->end - pool->start)*2;
- pool->blocks = realloc(pool->blocks, offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
+ pool->blocks = pool->mem->realloc_fcn(pool->blocks, offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
if (!pool->blocks)
return 0;
pool->blocks->size = blockSize;
blockSize = INIT_BLOCK_SIZE;
else
blockSize *= 2;
- tem = malloc(offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
+ tem = pool->mem->malloc_fcn(offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
if (!tem)
return 0;
tem->size = blockSize;
int next;
if (! dtd.scaffIndex) {
- dtd.scaffIndex = malloc(groupSize * sizeof(int));
+ dtd.scaffIndex = MALLOC(groupSize * sizeof(int));
if (! dtd.scaffIndex)
return -1;
dtd.scaffIndex[0] = 0;
if (dtd.scaffCount >= dtd.scaffSize) {
if (dtd.scaffold) {
dtd.scaffSize *= 2;
- dtd.scaffold = (CONTENT_SCAFFOLD *) realloc(dtd.scaffold,
+ dtd.scaffold = (CONTENT_SCAFFOLD *) REALLOC(dtd.scaffold,
dtd.scaffSize * sizeof(CONTENT_SCAFFOLD));
}
else {
dtd.scaffSize = 32;
- dtd.scaffold = (CONTENT_SCAFFOLD *) malloc(dtd.scaffSize * sizeof(CONTENT_SCAFFOLD));
+ dtd.scaffold = (CONTENT_SCAFFOLD *) MALLOC(dtd.scaffSize * sizeof(CONTENT_SCAFFOLD));
}
if (! dtd.scaffold)
return -1;
char * str;
int allocsize = dtd.scaffCount * sizeof(XML_Content) + dtd.contentStringLen;
- ret = malloc(allocsize);
+ ret = MALLOC(allocsize);
if (! ret)
return 0;
projects / libexpat / commitdiff