Updated expat
This commit is contained in:
parent
5a3c3447b7
commit
abd5708e5c
@ -742,6 +742,29 @@ XML_GetSpecifiedAttributeCount(XML_Parser parser);
|
|||||||
XMLPARSEAPI(int)
|
XMLPARSEAPI(int)
|
||||||
XML_GetIdAttributeIndex(XML_Parser parser);
|
XML_GetIdAttributeIndex(XML_Parser parser);
|
||||||
|
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
/* Source file byte offsets for the start and end of attribute names and values.
|
||||||
|
The value indices are exclusive of surrounding quotes; thus in a UTF-8 source
|
||||||
|
file an attribute value of "blah" will yield:
|
||||||
|
info->valueEnd - info->valueStart = 4 bytes.
|
||||||
|
*/
|
||||||
|
typedef struct {
|
||||||
|
XML_Index nameStart; /* Offset to beginning of the attribute name. */
|
||||||
|
XML_Index nameEnd; /* Offset after the attribute name's last byte. */
|
||||||
|
XML_Index valueStart; /* Offset to beginning of the attribute value. */
|
||||||
|
XML_Index valueEnd; /* Offset after the attribute value's last byte. */
|
||||||
|
} XML_AttrInfo;
|
||||||
|
|
||||||
|
/* Returns an array of XML_AttrInfo structures for the attribute/value pairs
|
||||||
|
passed in last call to the XML_StartElementHandler that were specified
|
||||||
|
in the start-tag rather than defaulted. Each attribute/value pair counts
|
||||||
|
as 1; thus the number of entries in the array is
|
||||||
|
XML_GetSpecifiedAttributeCount(parser) / 2.
|
||||||
|
*/
|
||||||
|
XMLPARSEAPI(const XML_AttrInfo *)
|
||||||
|
XML_GetAttributeInfo(XML_Parser parser);
|
||||||
|
#endif
|
||||||
|
|
||||||
/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
|
/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
|
||||||
detected. The last call to XML_Parse must have isFinal true; len
|
detected. The last call to XML_Parse must have isFinal true; len
|
||||||
may be zero for this call (or any other).
|
may be zero for this call (or any other).
|
||||||
@ -883,6 +906,15 @@ XMLPARSEAPI(int)
|
|||||||
XML_SetParamEntityParsing(XML_Parser parser,
|
XML_SetParamEntityParsing(XML_Parser parser,
|
||||||
enum XML_ParamEntityParsing parsing);
|
enum XML_ParamEntityParsing parsing);
|
||||||
|
|
||||||
|
/* Sets the hash salt to use for internal hash calculations.
|
||||||
|
Helps in preventing DoS attacks based on predicting hash
|
||||||
|
function behavior. This must be called before parsing is started.
|
||||||
|
Returns 1 if successful, 0 when called after parsing has started.
|
||||||
|
*/
|
||||||
|
XMLPARSEAPI(int)
|
||||||
|
XML_SetHashSalt(XML_Parser parser,
|
||||||
|
unsigned long hash_salt);
|
||||||
|
|
||||||
/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
|
/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
|
||||||
XML_GetErrorCode returns information about the error.
|
XML_GetErrorCode returns information about the error.
|
||||||
*/
|
*/
|
||||||
@ -984,7 +1016,8 @@ enum XML_FeatureEnum {
|
|||||||
XML_FEATURE_SIZEOF_XML_CHAR,
|
XML_FEATURE_SIZEOF_XML_CHAR,
|
||||||
XML_FEATURE_SIZEOF_XML_LCHAR,
|
XML_FEATURE_SIZEOF_XML_LCHAR,
|
||||||
XML_FEATURE_NS,
|
XML_FEATURE_NS,
|
||||||
XML_FEATURE_LARGE_SIZE
|
XML_FEATURE_LARGE_SIZE,
|
||||||
|
XML_FEATURE_ATTR_INFO
|
||||||
/* Additional features must be added to the end of this enum. */
|
/* Additional features must be added to the end of this enum. */
|
||||||
};
|
};
|
||||||
|
|
||||||
@ -1004,8 +1037,8 @@ XML_GetFeatureList(void);
|
|||||||
change to major or minor version.
|
change to major or minor version.
|
||||||
*/
|
*/
|
||||||
#define XML_MAJOR_VERSION 2
|
#define XML_MAJOR_VERSION 2
|
||||||
#define XML_MINOR_VERSION 0
|
#define XML_MINOR_VERSION 1
|
||||||
#define XML_MICRO_VERSION 1
|
#define XML_MICRO_VERSION 0
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
}
|
}
|
||||||
|
@ -5,17 +5,18 @@
|
|||||||
#include <stddef.h>
|
#include <stddef.h>
|
||||||
#include <string.h> /* memset(), memcpy() */
|
#include <string.h> /* memset(), memcpy() */
|
||||||
#include <assert.h>
|
#include <assert.h>
|
||||||
|
#include <limits.h> /* UINT_MAX */
|
||||||
|
#include <time.h> /* time() */
|
||||||
|
|
||||||
#define XML_BUILDING_EXPAT 1
|
// 2013_04_09 _X: Quick and dirty "fix" for expat compilation under Linux and Windows:
|
||||||
|
|
||||||
// 2013_04_09 _X: Quick and dirty "fix" for expat compilation under Linux:
|
|
||||||
#define HAVE_MEMMOVE
|
#define HAVE_MEMMOVE
|
||||||
|
#define XML_BUILDING_EXPAT 1
|
||||||
|
|
||||||
#ifdef COMPILED_FROM_DSP
|
#ifdef COMPILED_FROM_DSP
|
||||||
#include "winconfig.h"
|
#include "winconfig.h"
|
||||||
#elif defined(MACOS_CLASSIC)
|
#elif defined(MACOS_CLASSIC)
|
||||||
#include "macconfig.h"
|
#include "macconfig.h"
|
||||||
#elif defined(__amigaos4__)
|
#elif defined(__amigaos__)
|
||||||
#include "amigaconfig.h"
|
#include "amigaconfig.h"
|
||||||
#elif defined(__WATCOMC__)
|
#elif defined(__WATCOMC__)
|
||||||
#include "watcomconfig.h"
|
#include "watcomconfig.h"
|
||||||
@ -394,12 +395,13 @@ static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);
|
|||||||
static void
|
static void
|
||||||
dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms);
|
dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms);
|
||||||
static int
|
static int
|
||||||
dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);
|
dtdCopy(XML_Parser oldParser,
|
||||||
|
DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);
|
||||||
static int
|
static int
|
||||||
copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);
|
copyEntityTable(XML_Parser oldParser,
|
||||||
|
HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);
|
||||||
static NAMED *
|
static NAMED *
|
||||||
lookup(HASH_TABLE *table, KEY name, size_t createSize);
|
lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize);
|
||||||
static void FASTCALL
|
static void FASTCALL
|
||||||
hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);
|
hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);
|
||||||
static void FASTCALL hashTableClear(HASH_TABLE *);
|
static void FASTCALL hashTableClear(HASH_TABLE *);
|
||||||
@ -432,11 +434,15 @@ static ELEMENT_TYPE *
|
|||||||
getElementType(XML_Parser parser, const ENCODING *enc,
|
getElementType(XML_Parser parser, const ENCODING *enc,
|
||||||
const char *ptr, const char *end);
|
const char *ptr, const char *end);
|
||||||
|
|
||||||
|
static unsigned long generate_hash_secret_salt(void);
|
||||||
|
static XML_Bool startParsing(XML_Parser parser);
|
||||||
|
|
||||||
static XML_Parser
|
static XML_Parser
|
||||||
parserCreate(const XML_Char *encodingName,
|
parserCreate(const XML_Char *encodingName,
|
||||||
const XML_Memory_Handling_Suite *memsuite,
|
const XML_Memory_Handling_Suite *memsuite,
|
||||||
const XML_Char *nameSep,
|
const XML_Char *nameSep,
|
||||||
DTD *dtd);
|
DTD *dtd);
|
||||||
|
|
||||||
static void
|
static void
|
||||||
parserInit(XML_Parser parser, const XML_Char *encodingName);
|
parserInit(XML_Parser parser, const XML_Char *encodingName);
|
||||||
|
|
||||||
@ -536,6 +542,9 @@ struct XML_ParserStruct {
|
|||||||
NS_ATT *m_nsAtts;
|
NS_ATT *m_nsAtts;
|
||||||
unsigned long m_nsAttsVersion;
|
unsigned long m_nsAttsVersion;
|
||||||
unsigned char m_nsAttsPower;
|
unsigned char m_nsAttsPower;
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
XML_AttrInfo *m_attInfo;
|
||||||
|
#endif
|
||||||
POSITION m_position;
|
POSITION m_position;
|
||||||
STRING_POOL m_tempPool;
|
STRING_POOL m_tempPool;
|
||||||
STRING_POOL m_temp2Pool;
|
STRING_POOL m_temp2Pool;
|
||||||
@ -549,6 +558,7 @@ struct XML_ParserStruct {
|
|||||||
XML_Bool m_useForeignDTD;
|
XML_Bool m_useForeignDTD;
|
||||||
enum XML_ParamEntityParsing m_paramEntityParsing;
|
enum XML_ParamEntityParsing m_paramEntityParsing;
|
||||||
#endif
|
#endif
|
||||||
|
unsigned long m_hash_secret_salt;
|
||||||
};
|
};
|
||||||
|
|
||||||
#define MALLOC(s) (parser->m_mem.malloc_fcn((s)))
|
#define MALLOC(s) (parser->m_mem.malloc_fcn((s)))
|
||||||
@ -643,6 +653,7 @@ struct XML_ParserStruct {
|
|||||||
#define nsAtts (parser->m_nsAtts)
|
#define nsAtts (parser->m_nsAtts)
|
||||||
#define nsAttsVersion (parser->m_nsAttsVersion)
|
#define nsAttsVersion (parser->m_nsAttsVersion)
|
||||||
#define nsAttsPower (parser->m_nsAttsPower)
|
#define nsAttsPower (parser->m_nsAttsPower)
|
||||||
|
#define attInfo (parser->m_attInfo)
|
||||||
#define tempPool (parser->m_tempPool)
|
#define tempPool (parser->m_tempPool)
|
||||||
#define temp2Pool (parser->m_temp2Pool)
|
#define temp2Pool (parser->m_temp2Pool)
|
||||||
#define groupConnector (parser->m_groupConnector)
|
#define groupConnector (parser->m_groupConnector)
|
||||||
@ -656,6 +667,7 @@ struct XML_ParserStruct {
|
|||||||
#define useForeignDTD (parser->m_useForeignDTD)
|
#define useForeignDTD (parser->m_useForeignDTD)
|
||||||
#define paramEntityParsing (parser->m_paramEntityParsing)
|
#define paramEntityParsing (parser->m_paramEntityParsing)
|
||||||
#endif /* XML_DTD */
|
#endif /* XML_DTD */
|
||||||
|
#define hash_secret_salt (parser->m_hash_secret_salt)
|
||||||
|
|
||||||
XML_Parser XMLCALL
|
XML_Parser XMLCALL
|
||||||
XML_ParserCreate(const XML_Char *encodingName)
|
XML_ParserCreate(const XML_Char *encodingName)
|
||||||
@ -680,22 +692,35 @@ static const XML_Char implicitContext[] = {
|
|||||||
ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0'
|
ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0'
|
||||||
};
|
};
|
||||||
|
|
||||||
|
static unsigned long
|
||||||
|
generate_hash_secret_salt(void)
|
||||||
|
{
|
||||||
|
unsigned int seed = time(NULL) % UINT_MAX;
|
||||||
|
srand(seed);
|
||||||
|
return rand();
|
||||||
|
}
|
||||||
|
|
||||||
|
static XML_Bool /* only valid for root parser */
|
||||||
|
startParsing(XML_Parser parser)
|
||||||
|
{
|
||||||
|
/* hash functions must be initialized before setContext() is called */
|
||||||
|
if (hash_secret_salt == 0)
|
||||||
|
hash_secret_salt = generate_hash_secret_salt();
|
||||||
|
if (ns) {
|
||||||
|
/* implicit context only set for root parser, since child
|
||||||
|
parsers (i.e. external entity parsers) will inherit it
|
||||||
|
*/
|
||||||
|
return setContext(parser, implicitContext);
|
||||||
|
}
|
||||||
|
return XML_TRUE;
|
||||||
|
}
|
||||||
|
|
||||||
XML_Parser XMLCALL
|
XML_Parser XMLCALL
|
||||||
XML_ParserCreate_MM(const XML_Char *encodingName,
|
XML_ParserCreate_MM(const XML_Char *encodingName,
|
||||||
const XML_Memory_Handling_Suite *memsuite,
|
const XML_Memory_Handling_Suite *memsuite,
|
||||||
const XML_Char *nameSep)
|
const XML_Char *nameSep)
|
||||||
{
|
{
|
||||||
XML_Parser parser = parserCreate(encodingName, memsuite, nameSep, NULL);
|
return parserCreate(encodingName, memsuite, nameSep, NULL);
|
||||||
if (parser != NULL && ns) {
|
|
||||||
/* implicit context only set for root parser, since child
|
|
||||||
parsers (i.e. external entity parsers) will inherit it
|
|
||||||
*/
|
|
||||||
if (!setContext(parser, implicitContext)) {
|
|
||||||
XML_ParserFree(parser);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return parser;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static XML_Parser
|
static XML_Parser
|
||||||
@ -740,9 +765,20 @@ parserCreate(const XML_Char *encodingName,
|
|||||||
FREE(parser);
|
FREE(parser);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
attInfo = (XML_AttrInfo*)MALLOC(attsSize * sizeof(XML_AttrInfo));
|
||||||
|
if (attInfo == NULL) {
|
||||||
|
FREE(atts);
|
||||||
|
FREE(parser);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
dataBuf = (XML_Char *)MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
|
dataBuf = (XML_Char *)MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
|
||||||
if (dataBuf == NULL) {
|
if (dataBuf == NULL) {
|
||||||
FREE(atts);
|
FREE(atts);
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
FREE(attInfo);
|
||||||
|
#endif
|
||||||
FREE(parser);
|
FREE(parser);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
@ -755,6 +791,9 @@ parserCreate(const XML_Char *encodingName,
|
|||||||
if (_dtd == NULL) {
|
if (_dtd == NULL) {
|
||||||
FREE(dataBuf);
|
FREE(dataBuf);
|
||||||
FREE(atts);
|
FREE(atts);
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
FREE(attInfo);
|
||||||
|
#endif
|
||||||
FREE(parser);
|
FREE(parser);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
@ -869,6 +908,7 @@ parserInit(XML_Parser parser, const XML_Char *encodingName)
|
|||||||
useForeignDTD = XML_FALSE;
|
useForeignDTD = XML_FALSE;
|
||||||
paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
|
paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
|
||||||
#endif
|
#endif
|
||||||
|
hash_secret_salt = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* moves list of bindings to freeBindingList */
|
/* moves list of bindings to freeBindingList */
|
||||||
@ -916,7 +956,7 @@ XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)
|
|||||||
poolClear(&temp2Pool);
|
poolClear(&temp2Pool);
|
||||||
parserInit(parser, encodingName);
|
parserInit(parser, encodingName);
|
||||||
dtdReset(_dtd, &parser->m_mem);
|
dtdReset(_dtd, &parser->m_mem);
|
||||||
return setContext(parser, implicitContext);
|
return XML_TRUE;
|
||||||
}
|
}
|
||||||
|
|
||||||
enum XML_Status XMLCALL
|
enum XML_Status XMLCALL
|
||||||
@ -985,6 +1025,12 @@ XML_ExternalEntityParserCreate(XML_Parser oldParser,
|
|||||||
int oldInEntityValue = prologState.inEntityValue;
|
int oldInEntityValue = prologState.inEntityValue;
|
||||||
#endif
|
#endif
|
||||||
XML_Bool oldns_triplets = ns_triplets;
|
XML_Bool oldns_triplets = ns_triplets;
|
||||||
|
/* Note that the new parser shares the same hash secret as the old
|
||||||
|
parser, so that dtdCopy and copyEntityTable can lookup values
|
||||||
|
from hash tables associated with either parser without us having
|
||||||
|
to worry which hash secrets each table has.
|
||||||
|
*/
|
||||||
|
unsigned long oldhash_secret_salt = hash_secret_salt;
|
||||||
|
|
||||||
#ifdef XML_DTD
|
#ifdef XML_DTD
|
||||||
if (!context)
|
if (!context)
|
||||||
@ -1038,13 +1084,14 @@ XML_ExternalEntityParserCreate(XML_Parser oldParser,
|
|||||||
externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
|
externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
|
||||||
defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
|
defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
|
||||||
ns_triplets = oldns_triplets;
|
ns_triplets = oldns_triplets;
|
||||||
|
hash_secret_salt = oldhash_secret_salt;
|
||||||
parentParser = oldParser;
|
parentParser = oldParser;
|
||||||
#ifdef XML_DTD
|
#ifdef XML_DTD
|
||||||
paramEntityParsing = oldParamEntityParsing;
|
paramEntityParsing = oldParamEntityParsing;
|
||||||
prologState.inEntityValue = oldInEntityValue;
|
prologState.inEntityValue = oldInEntityValue;
|
||||||
if (context) {
|
if (context) {
|
||||||
#endif /* XML_DTD */
|
#endif /* XML_DTD */
|
||||||
if (!dtdCopy(_dtd, oldDtd, &parser->m_mem)
|
if (!dtdCopy(oldParser, _dtd, oldDtd, &parser->m_mem)
|
||||||
|| !setContext(parser, context)) {
|
|| !setContext(parser, context)) {
|
||||||
XML_ParserFree(parser);
|
XML_ParserFree(parser);
|
||||||
return NULL;
|
return NULL;
|
||||||
@ -1133,6 +1180,9 @@ XML_ParserFree(XML_Parser parser)
|
|||||||
#endif /* XML_DTD */
|
#endif /* XML_DTD */
|
||||||
dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);
|
dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);
|
||||||
FREE((void *)atts);
|
FREE((void *)atts);
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
FREE((void *)attInfo);
|
||||||
|
#endif
|
||||||
FREE(groupConnector);
|
FREE(groupConnector);
|
||||||
FREE(buffer);
|
FREE(buffer);
|
||||||
FREE(dataBuf);
|
FREE(dataBuf);
|
||||||
@ -1213,6 +1263,14 @@ XML_GetIdAttributeIndex(XML_Parser parser)
|
|||||||
return idAttIndex;
|
return idAttIndex;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
const XML_AttrInfo * XMLCALL
|
||||||
|
XML_GetAttributeInfo(XML_Parser parser)
|
||||||
|
{
|
||||||
|
return attInfo;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
void XMLCALL
|
void XMLCALL
|
||||||
XML_SetElementHandler(XML_Parser parser,
|
XML_SetElementHandler(XML_Parser parser,
|
||||||
XML_StartElementHandler start,
|
XML_StartElementHandler start,
|
||||||
@ -1429,6 +1487,17 @@ XML_SetParamEntityParsing(XML_Parser parser,
|
|||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
int XMLCALL
|
||||||
|
XML_SetHashSalt(XML_Parser parser,
|
||||||
|
unsigned long hash_salt)
|
||||||
|
{
|
||||||
|
/* block after XML_Parse()/XML_ParseBuffer() has been called */
|
||||||
|
if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
|
||||||
|
return 0;
|
||||||
|
hash_secret_salt = hash_salt;
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
enum XML_Status XMLCALL
|
enum XML_Status XMLCALL
|
||||||
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
|
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
|
||||||
{
|
{
|
||||||
@ -1439,6 +1508,11 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
|
|||||||
case XML_FINISHED:
|
case XML_FINISHED:
|
||||||
errorCode = XML_ERROR_FINISHED;
|
errorCode = XML_ERROR_FINISHED;
|
||||||
return XML_STATUS_ERROR;
|
return XML_STATUS_ERROR;
|
||||||
|
case XML_INITIALIZED:
|
||||||
|
if (parentParser == NULL && !startParsing(parser)) {
|
||||||
|
errorCode = XML_ERROR_NO_MEMORY;
|
||||||
|
return XML_STATUS_ERROR;
|
||||||
|
}
|
||||||
default:
|
default:
|
||||||
ps_parsing = XML_PARSING;
|
ps_parsing = XML_PARSING;
|
||||||
}
|
}
|
||||||
@ -1497,11 +1571,13 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
|
|||||||
break;
|
break;
|
||||||
case XML_INITIALIZED:
|
case XML_INITIALIZED:
|
||||||
case XML_PARSING:
|
case XML_PARSING:
|
||||||
result = XML_STATUS_OK;
|
|
||||||
if (isFinal) {
|
if (isFinal) {
|
||||||
ps_parsing = XML_FINISHED;
|
ps_parsing = XML_FINISHED;
|
||||||
return result;
|
return XML_STATUS_OK;
|
||||||
}
|
}
|
||||||
|
/* fall through */
|
||||||
|
default:
|
||||||
|
result = XML_STATUS_OK;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1515,16 +1591,12 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
|
|||||||
? (char *)MALLOC(len * 2)
|
? (char *)MALLOC(len * 2)
|
||||||
: (char *)REALLOC(buffer, len * 2));
|
: (char *)REALLOC(buffer, len * 2));
|
||||||
if (temp == NULL) {
|
if (temp == NULL) {
|
||||||
errorCode = XML_ERROR_NO_MEMORY;
|
|
||||||
return XML_STATUS_ERROR;
|
|
||||||
}
|
|
||||||
buffer = temp;
|
|
||||||
if (!buffer) {
|
|
||||||
errorCode = XML_ERROR_NO_MEMORY;
|
errorCode = XML_ERROR_NO_MEMORY;
|
||||||
eventPtr = eventEndPtr = NULL;
|
eventPtr = eventEndPtr = NULL;
|
||||||
processor = errorProcessor;
|
processor = errorProcessor;
|
||||||
return XML_STATUS_ERROR;
|
return XML_STATUS_ERROR;
|
||||||
}
|
}
|
||||||
|
buffer = temp;
|
||||||
bufferLim = buffer + len * 2;
|
bufferLim = buffer + len * 2;
|
||||||
}
|
}
|
||||||
memcpy(buffer, end, nLeftOver);
|
memcpy(buffer, end, nLeftOver);
|
||||||
@ -1562,6 +1634,11 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
|
|||||||
case XML_FINISHED:
|
case XML_FINISHED:
|
||||||
errorCode = XML_ERROR_FINISHED;
|
errorCode = XML_ERROR_FINISHED;
|
||||||
return XML_STATUS_ERROR;
|
return XML_STATUS_ERROR;
|
||||||
|
case XML_INITIALIZED:
|
||||||
|
if (parentParser == NULL && !startParsing(parser)) {
|
||||||
|
errorCode = XML_ERROR_NO_MEMORY;
|
||||||
|
return XML_STATUS_ERROR;
|
||||||
|
}
|
||||||
default:
|
default:
|
||||||
ps_parsing = XML_PARSING;
|
ps_parsing = XML_PARSING;
|
||||||
}
|
}
|
||||||
@ -1675,6 +1752,8 @@ XML_GetBuffer(XML_Parser parser, int len)
|
|||||||
bufferPtr = buffer = newBuf;
|
bufferPtr = buffer = newBuf;
|
||||||
#endif /* not defined XML_CONTEXT_BYTES */
|
#endif /* not defined XML_CONTEXT_BYTES */
|
||||||
}
|
}
|
||||||
|
eventPtr = eventEndPtr = NULL;
|
||||||
|
positionPtr = NULL;
|
||||||
}
|
}
|
||||||
return bufferEnd;
|
return bufferEnd;
|
||||||
}
|
}
|
||||||
@ -1959,6 +2038,9 @@ XML_GetFeatureList(void)
|
|||||||
#endif
|
#endif
|
||||||
#ifdef XML_LARGE_SIZE
|
#ifdef XML_LARGE_SIZE
|
||||||
{XML_FEATURE_LARGE_SIZE, XML_L("XML_LARGE_SIZE"), 0},
|
{XML_FEATURE_LARGE_SIZE, XML_L("XML_LARGE_SIZE"), 0},
|
||||||
|
#endif
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
{XML_FEATURE_ATTR_INFO, XML_L("XML_ATTR_INFO"), 0},
|
||||||
#endif
|
#endif
|
||||||
{XML_FEATURE_END, NULL, 0}
|
{XML_FEATURE_END, NULL, 0}
|
||||||
};
|
};
|
||||||
@ -2243,7 +2325,7 @@ doContent(XML_Parser parser,
|
|||||||
next - enc->minBytesPerChar);
|
next - enc->minBytesPerChar);
|
||||||
if (!name)
|
if (!name)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
|
entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
|
||||||
poolDiscard(&dtd->pool);
|
poolDiscard(&dtd->pool);
|
||||||
/* First, determine if a check for an existing declaration is needed;
|
/* First, determine if a check for an existing declaration is needed;
|
||||||
if yes, check that the entity exists, and that it is internal,
|
if yes, check that the entity exists, and that it is internal,
|
||||||
@ -2633,12 +2715,12 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
|
|||||||
const XML_Char *localPart;
|
const XML_Char *localPart;
|
||||||
|
|
||||||
/* lookup the element type name */
|
/* lookup the element type name */
|
||||||
elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, tagNamePtr->str,0);
|
elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str,0);
|
||||||
if (!elementType) {
|
if (!elementType) {
|
||||||
const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
|
const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
|
||||||
if (!name)
|
if (!name)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, name,
|
elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
|
||||||
sizeof(ELEMENT_TYPE));
|
sizeof(ELEMENT_TYPE));
|
||||||
if (!elementType)
|
if (!elementType)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
@ -2652,23 +2734,44 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
|
|||||||
if (n + nDefaultAtts > attsSize) {
|
if (n + nDefaultAtts > attsSize) {
|
||||||
int oldAttsSize = attsSize;
|
int oldAttsSize = attsSize;
|
||||||
ATTRIBUTE *temp;
|
ATTRIBUTE *temp;
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
XML_AttrInfo *temp2;
|
||||||
|
#endif
|
||||||
attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
|
attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
|
||||||
temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
|
temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
|
||||||
if (temp == NULL)
|
if (temp == NULL)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
atts = temp;
|
atts = temp;
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
temp2 = (XML_AttrInfo *)REALLOC((void *)attInfo, attsSize * sizeof(XML_AttrInfo));
|
||||||
|
if (temp2 == NULL)
|
||||||
|
return XML_ERROR_NO_MEMORY;
|
||||||
|
attInfo = temp2;
|
||||||
|
#endif
|
||||||
if (n > oldAttsSize)
|
if (n > oldAttsSize)
|
||||||
XmlGetAttributes(enc, attStr, n, atts);
|
XmlGetAttributes(enc, attStr, n, atts);
|
||||||
}
|
}
|
||||||
|
|
||||||
appAtts = (const XML_Char **)atts;
|
appAtts = (const XML_Char **)atts;
|
||||||
for (i = 0; i < n; i++) {
|
for (i = 0; i < n; i++) {
|
||||||
|
ATTRIBUTE *currAtt = &atts[i];
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
XML_AttrInfo *currAttInfo = &attInfo[i];
|
||||||
|
#endif
|
||||||
/* add the name and value to the attribute list */
|
/* add the name and value to the attribute list */
|
||||||
ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,
|
ATTRIBUTE_ID *attId = getAttributeId(parser, enc, currAtt->name,
|
||||||
atts[i].name
|
currAtt->name
|
||||||
+ XmlNameLength(enc, atts[i].name));
|
+ XmlNameLength(enc, currAtt->name));
|
||||||
if (!attId)
|
if (!attId)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
|
#ifdef XML_ATTR_INFO
|
||||||
|
currAttInfo->nameStart = parseEndByteIndex - (parseEndPtr - currAtt->name);
|
||||||
|
currAttInfo->nameEnd = currAttInfo->nameStart +
|
||||||
|
XmlNameLength(enc, currAtt->name);
|
||||||
|
currAttInfo->valueStart = parseEndByteIndex -
|
||||||
|
(parseEndPtr - currAtt->valuePtr);
|
||||||
|
currAttInfo->valueEnd = parseEndByteIndex - (parseEndPtr - currAtt->valueEnd);
|
||||||
|
#endif
|
||||||
/* Detect duplicate attributes by their QNames. This does not work when
|
/* Detect duplicate attributes by their QNames. This does not work when
|
||||||
namespace processing is turned on and different prefixes for the same
|
namespace processing is turned on and different prefixes for the same
|
||||||
namespace are used. For this case we have a check further down.
|
namespace are used. For this case we have a check further down.
|
||||||
@ -2807,9 +2910,9 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
|
|||||||
if (s[-1] == 2) { /* prefixed */
|
if (s[-1] == 2) { /* prefixed */
|
||||||
ATTRIBUTE_ID *id;
|
ATTRIBUTE_ID *id;
|
||||||
const BINDING *b;
|
const BINDING *b;
|
||||||
unsigned long uriHash = 0;
|
unsigned long uriHash = hash_secret_salt;
|
||||||
((XML_Char *)s)[-1] = 0; /* clear flag */
|
((XML_Char *)s)[-1] = 0; /* clear flag */
|
||||||
id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, s, 0);
|
id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
|
||||||
b = id->prefix->binding;
|
b = id->prefix->binding;
|
||||||
if (!b)
|
if (!b)
|
||||||
return XML_ERROR_UNBOUND_PREFIX;
|
return XML_ERROR_UNBOUND_PREFIX;
|
||||||
@ -2831,7 +2934,7 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
|
|||||||
} while (*s++);
|
} while (*s++);
|
||||||
|
|
||||||
{ /* Check hash table for duplicate of expanded name (uriName).
|
{ /* Check hash table for duplicate of expanded name (uriName).
|
||||||
Derived from code in lookup(HASH_TABLE *table, ...).
|
Derived from code in lookup(parser, HASH_TABLE *table, ...).
|
||||||
*/
|
*/
|
||||||
unsigned char step = 0;
|
unsigned char step = 0;
|
||||||
unsigned long mask = nsAttsSize - 1;
|
unsigned long mask = nsAttsSize - 1;
|
||||||
@ -3706,6 +3809,9 @@ doProlog(XML_Parser parser,
|
|||||||
return XML_ERROR_UNCLOSED_TOKEN;
|
return XML_ERROR_UNCLOSED_TOKEN;
|
||||||
case XML_TOK_PARTIAL_CHAR:
|
case XML_TOK_PARTIAL_CHAR:
|
||||||
return XML_ERROR_PARTIAL_CHAR;
|
return XML_ERROR_PARTIAL_CHAR;
|
||||||
|
case -XML_TOK_PROLOG_S:
|
||||||
|
tok = -tok;
|
||||||
|
break;
|
||||||
case XML_TOK_NONE:
|
case XML_TOK_NONE:
|
||||||
#ifdef XML_DTD
|
#ifdef XML_DTD
|
||||||
/* for internal PE NOT referenced between declarations */
|
/* for internal PE NOT referenced between declarations */
|
||||||
@ -3777,7 +3883,8 @@ doProlog(XML_Parser parser,
|
|||||||
case XML_ROLE_DOCTYPE_PUBLIC_ID:
|
case XML_ROLE_DOCTYPE_PUBLIC_ID:
|
||||||
#ifdef XML_DTD
|
#ifdef XML_DTD
|
||||||
useForeignDTD = XML_FALSE;
|
useForeignDTD = XML_FALSE;
|
||||||
declEntity = (ENTITY *)lookup(&dtd->paramEntities,
|
declEntity = (ENTITY *)lookup(parser,
|
||||||
|
&dtd->paramEntities,
|
||||||
externalSubsetName,
|
externalSubsetName,
|
||||||
sizeof(ENTITY));
|
sizeof(ENTITY));
|
||||||
if (!declEntity)
|
if (!declEntity)
|
||||||
@ -3785,15 +3892,17 @@ doProlog(XML_Parser parser,
|
|||||||
#endif /* XML_DTD */
|
#endif /* XML_DTD */
|
||||||
dtd->hasParamEntityRefs = XML_TRUE;
|
dtd->hasParamEntityRefs = XML_TRUE;
|
||||||
if (startDoctypeDeclHandler) {
|
if (startDoctypeDeclHandler) {
|
||||||
|
XML_Char *pubId;
|
||||||
if (!XmlIsPublicId(enc, s, next, eventPP))
|
if (!XmlIsPublicId(enc, s, next, eventPP))
|
||||||
return XML_ERROR_PUBLICID;
|
return XML_ERROR_PUBLICID;
|
||||||
doctypePubid = poolStoreString(&tempPool, enc,
|
pubId = poolStoreString(&tempPool, enc,
|
||||||
s + enc->minBytesPerChar,
|
s + enc->minBytesPerChar,
|
||||||
next - enc->minBytesPerChar);
|
next - enc->minBytesPerChar);
|
||||||
if (!doctypePubid)
|
if (!pubId)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
normalizePublicId((XML_Char *)doctypePubid);
|
normalizePublicId(pubId);
|
||||||
poolFinish(&tempPool);
|
poolFinish(&tempPool);
|
||||||
|
doctypePubid = pubId;
|
||||||
handleDefault = XML_FALSE;
|
handleDefault = XML_FALSE;
|
||||||
goto alreadyChecked;
|
goto alreadyChecked;
|
||||||
}
|
}
|
||||||
@ -3832,7 +3941,8 @@ doProlog(XML_Parser parser,
|
|||||||
XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
|
XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
|
||||||
dtd->hasParamEntityRefs = XML_TRUE;
|
dtd->hasParamEntityRefs = XML_TRUE;
|
||||||
if (paramEntityParsing && externalEntityRefHandler) {
|
if (paramEntityParsing && externalEntityRefHandler) {
|
||||||
ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,
|
ENTITY *entity = (ENTITY *)lookup(parser,
|
||||||
|
&dtd->paramEntities,
|
||||||
externalSubsetName,
|
externalSubsetName,
|
||||||
sizeof(ENTITY));
|
sizeof(ENTITY));
|
||||||
if (!entity)
|
if (!entity)
|
||||||
@ -3876,7 +3986,7 @@ doProlog(XML_Parser parser,
|
|||||||
XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
|
XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
|
||||||
dtd->hasParamEntityRefs = XML_TRUE;
|
dtd->hasParamEntityRefs = XML_TRUE;
|
||||||
if (paramEntityParsing && externalEntityRefHandler) {
|
if (paramEntityParsing && externalEntityRefHandler) {
|
||||||
ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,
|
ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
|
||||||
externalSubsetName,
|
externalSubsetName,
|
||||||
sizeof(ENTITY));
|
sizeof(ENTITY));
|
||||||
if (!entity)
|
if (!entity)
|
||||||
@ -4090,7 +4200,8 @@ doProlog(XML_Parser parser,
|
|||||||
break;
|
break;
|
||||||
#else /* XML_DTD */
|
#else /* XML_DTD */
|
||||||
if (!declEntity) {
|
if (!declEntity) {
|
||||||
declEntity = (ENTITY *)lookup(&dtd->paramEntities,
|
declEntity = (ENTITY *)lookup(parser,
|
||||||
|
&dtd->paramEntities,
|
||||||
externalSubsetName,
|
externalSubsetName,
|
||||||
sizeof(ENTITY));
|
sizeof(ENTITY));
|
||||||
if (!declEntity)
|
if (!declEntity)
|
||||||
@ -4165,7 +4276,7 @@ doProlog(XML_Parser parser,
|
|||||||
const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
|
const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
|
||||||
if (!name)
|
if (!name)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
declEntity = (ENTITY *)lookup(&dtd->generalEntities, name,
|
declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities, name,
|
||||||
sizeof(ENTITY));
|
sizeof(ENTITY));
|
||||||
if (!declEntity)
|
if (!declEntity)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
@ -4197,7 +4308,7 @@ doProlog(XML_Parser parser,
|
|||||||
const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
|
const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
|
||||||
if (!name)
|
if (!name)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
declEntity = (ENTITY *)lookup(&dtd->paramEntities,
|
declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
|
||||||
name, sizeof(ENTITY));
|
name, sizeof(ENTITY));
|
||||||
if (!declEntity)
|
if (!declEntity)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
@ -4379,7 +4490,7 @@ doProlog(XML_Parser parser,
|
|||||||
next - enc->minBytesPerChar);
|
next - enc->minBytesPerChar);
|
||||||
if (!name)
|
if (!name)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
|
entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
|
||||||
poolDiscard(&dtd->pool);
|
poolDiscard(&dtd->pool);
|
||||||
/* first, determine if a check for an existing declaration is needed;
|
/* first, determine if a check for an existing declaration is needed;
|
||||||
if yes, check that the entity exists, and that it is internal,
|
if yes, check that the entity exists, and that it is internal,
|
||||||
@ -4806,10 +4917,6 @@ errorProcessor(XML_Parser parser,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const char **nextPtr)
|
const char **nextPtr)
|
||||||
{
|
{
|
||||||
(void)s;
|
|
||||||
(void)end;
|
|
||||||
(void)nextPtr;
|
|
||||||
|
|
||||||
return errorCode;
|
return errorCode;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -4907,7 +5014,7 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
|
|||||||
next - enc->minBytesPerChar);
|
next - enc->minBytesPerChar);
|
||||||
if (!name)
|
if (!name)
|
||||||
return XML_ERROR_NO_MEMORY;
|
return XML_ERROR_NO_MEMORY;
|
||||||
entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
|
entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
|
||||||
poolDiscard(&temp2Pool);
|
poolDiscard(&temp2Pool);
|
||||||
/* First, determine if a check for an existing declaration is needed;
|
/* First, determine if a check for an existing declaration is needed;
|
||||||
if yes, check that the entity exists, and that it is internal.
|
if yes, check that the entity exists, and that it is internal.
|
||||||
@ -5016,7 +5123,7 @@ storeEntityValue(XML_Parser parser,
|
|||||||
result = XML_ERROR_NO_MEMORY;
|
result = XML_ERROR_NO_MEMORY;
|
||||||
goto endEntityValue;
|
goto endEntityValue;
|
||||||
}
|
}
|
||||||
entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
|
entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
|
||||||
poolDiscard(&tempPool);
|
poolDiscard(&tempPool);
|
||||||
if (!entity) {
|
if (!entity) {
|
||||||
/* not a well-formedness error - see XML 1.0: WFC Entity Declared */
|
/* not a well-formedness error - see XML 1.0: WFC Entity Declared */
|
||||||
@ -5306,7 +5413,7 @@ setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType)
|
|||||||
}
|
}
|
||||||
if (!poolAppendChar(&dtd->pool, XML_T('\0')))
|
if (!poolAppendChar(&dtd->pool, XML_T('\0')))
|
||||||
return 0;
|
return 0;
|
||||||
prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),
|
prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
|
||||||
sizeof(PREFIX));
|
sizeof(PREFIX));
|
||||||
if (!prefix)
|
if (!prefix)
|
||||||
return 0;
|
return 0;
|
||||||
@ -5335,7 +5442,7 @@ getAttributeId(XML_Parser parser, const ENCODING *enc,
|
|||||||
return NULL;
|
return NULL;
|
||||||
/* skip quotation mark - its storage will be re-used (like in name[-1]) */
|
/* skip quotation mark - its storage will be re-used (like in name[-1]) */
|
||||||
++name;
|
++name;
|
||||||
id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));
|
id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));
|
||||||
if (!id)
|
if (!id)
|
||||||
return NULL;
|
return NULL;
|
||||||
if (id->name != name)
|
if (id->name != name)
|
||||||
@ -5353,7 +5460,7 @@ getAttributeId(XML_Parser parser, const ENCODING *enc,
|
|||||||
if (name[5] == XML_T('\0'))
|
if (name[5] == XML_T('\0'))
|
||||||
id->prefix = &dtd->defaultPrefix;
|
id->prefix = &dtd->defaultPrefix;
|
||||||
else
|
else
|
||||||
id->prefix = (PREFIX *)lookup(&dtd->prefixes, name + 6, sizeof(PREFIX));
|
id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6, sizeof(PREFIX));
|
||||||
id->xmlns = XML_TRUE;
|
id->xmlns = XML_TRUE;
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
@ -5368,7 +5475,7 @@ getAttributeId(XML_Parser parser, const ENCODING *enc,
|
|||||||
}
|
}
|
||||||
if (!poolAppendChar(&dtd->pool, XML_T('\0')))
|
if (!poolAppendChar(&dtd->pool, XML_T('\0')))
|
||||||
return NULL;
|
return NULL;
|
||||||
id->prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),
|
id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
|
||||||
sizeof(PREFIX));
|
sizeof(PREFIX));
|
||||||
if (id->prefix->name == poolStart(&dtd->pool))
|
if (id->prefix->name == poolStart(&dtd->pool))
|
||||||
poolFinish(&dtd->pool);
|
poolFinish(&dtd->pool);
|
||||||
@ -5464,7 +5571,7 @@ setContext(XML_Parser parser, const XML_Char *context)
|
|||||||
ENTITY *e;
|
ENTITY *e;
|
||||||
if (!poolAppendChar(&tempPool, XML_T('\0')))
|
if (!poolAppendChar(&tempPool, XML_T('\0')))
|
||||||
return XML_FALSE;
|
return XML_FALSE;
|
||||||
e = (ENTITY *)lookup(&dtd->generalEntities, poolStart(&tempPool), 0);
|
e = (ENTITY *)lookup(parser, &dtd->generalEntities, poolStart(&tempPool), 0);
|
||||||
if (e)
|
if (e)
|
||||||
e->open = XML_TRUE;
|
e->open = XML_TRUE;
|
||||||
if (*s != XML_T('\0'))
|
if (*s != XML_T('\0'))
|
||||||
@ -5479,7 +5586,7 @@ setContext(XML_Parser parser, const XML_Char *context)
|
|||||||
else {
|
else {
|
||||||
if (!poolAppendChar(&tempPool, XML_T('\0')))
|
if (!poolAppendChar(&tempPool, XML_T('\0')))
|
||||||
return XML_FALSE;
|
return XML_FALSE;
|
||||||
prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&tempPool),
|
prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&tempPool),
|
||||||
sizeof(PREFIX));
|
sizeof(PREFIX));
|
||||||
if (!prefix)
|
if (!prefix)
|
||||||
return XML_FALSE;
|
return XML_FALSE;
|
||||||
@ -5643,7 +5750,7 @@ dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms)
|
|||||||
The new DTD has already been initialized.
|
The new DTD has already been initialized.
|
||||||
*/
|
*/
|
||||||
static int
|
static int
|
||||||
dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
|
dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
|
||||||
{
|
{
|
||||||
HASH_TABLE_ITER iter;
|
HASH_TABLE_ITER iter;
|
||||||
|
|
||||||
@ -5658,7 +5765,7 @@ dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
|
|||||||
name = poolCopyString(&(newDtd->pool), oldP->name);
|
name = poolCopyString(&(newDtd->pool), oldP->name);
|
||||||
if (!name)
|
if (!name)
|
||||||
return 0;
|
return 0;
|
||||||
if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX)))
|
if (!lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -5680,7 +5787,7 @@ dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
|
|||||||
if (!name)
|
if (!name)
|
||||||
return 0;
|
return 0;
|
||||||
++name;
|
++name;
|
||||||
newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name,
|
newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,
|
||||||
sizeof(ATTRIBUTE_ID));
|
sizeof(ATTRIBUTE_ID));
|
||||||
if (!newA)
|
if (!newA)
|
||||||
return 0;
|
return 0;
|
||||||
@ -5690,7 +5797,7 @@ dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
|
|||||||
if (oldA->prefix == &oldDtd->defaultPrefix)
|
if (oldA->prefix == &oldDtd->defaultPrefix)
|
||||||
newA->prefix = &newDtd->defaultPrefix;
|
newA->prefix = &newDtd->defaultPrefix;
|
||||||
else
|
else
|
||||||
newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes),
|
newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
|
||||||
oldA->prefix->name, 0);
|
oldA->prefix->name, 0);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -5709,7 +5816,7 @@ dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
|
|||||||
name = poolCopyString(&(newDtd->pool), oldE->name);
|
name = poolCopyString(&(newDtd->pool), oldE->name);
|
||||||
if (!name)
|
if (!name)
|
||||||
return 0;
|
return 0;
|
||||||
newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name,
|
newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,
|
||||||
sizeof(ELEMENT_TYPE));
|
sizeof(ELEMENT_TYPE));
|
||||||
if (!newE)
|
if (!newE)
|
||||||
return 0;
|
return 0;
|
||||||
@ -5723,14 +5830,14 @@ dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
|
|||||||
}
|
}
|
||||||
if (oldE->idAtt)
|
if (oldE->idAtt)
|
||||||
newE->idAtt = (ATTRIBUTE_ID *)
|
newE->idAtt = (ATTRIBUTE_ID *)
|
||||||
lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0);
|
lookup(oldParser, &(newDtd->attributeIds), oldE->idAtt->name, 0);
|
||||||
newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
|
newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
|
||||||
if (oldE->prefix)
|
if (oldE->prefix)
|
||||||
newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes),
|
newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
|
||||||
oldE->prefix->name, 0);
|
oldE->prefix->name, 0);
|
||||||
for (i = 0; i < newE->nDefaultAtts; i++) {
|
for (i = 0; i < newE->nDefaultAtts; i++) {
|
||||||
newE->defaultAtts[i].id = (ATTRIBUTE_ID *)
|
newE->defaultAtts[i].id = (ATTRIBUTE_ID *)
|
||||||
lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
|
lookup(oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
|
||||||
newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
|
newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
|
||||||
if (oldE->defaultAtts[i].value) {
|
if (oldE->defaultAtts[i].value) {
|
||||||
newE->defaultAtts[i].value
|
newE->defaultAtts[i].value
|
||||||
@ -5744,13 +5851,15 @@ dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
|
|||||||
}
|
}
|
||||||
|
|
||||||
/* Copy the entity tables. */
|
/* Copy the entity tables. */
|
||||||
if (!copyEntityTable(&(newDtd->generalEntities),
|
if (!copyEntityTable(oldParser,
|
||||||
|
&(newDtd->generalEntities),
|
||||||
&(newDtd->pool),
|
&(newDtd->pool),
|
||||||
&(oldDtd->generalEntities)))
|
&(oldDtd->generalEntities)))
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
#ifdef XML_DTD
|
#ifdef XML_DTD
|
||||||
if (!copyEntityTable(&(newDtd->paramEntities),
|
if (!copyEntityTable(oldParser,
|
||||||
|
&(newDtd->paramEntities),
|
||||||
&(newDtd->pool),
|
&(newDtd->pool),
|
||||||
&(oldDtd->paramEntities)))
|
&(oldDtd->paramEntities)))
|
||||||
return 0;
|
return 0;
|
||||||
@ -5773,7 +5882,8 @@ dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
|
|||||||
} /* End dtdCopy */
|
} /* End dtdCopy */
|
||||||
|
|
||||||
static int
|
static int
|
||||||
copyEntityTable(HASH_TABLE *newTable,
|
copyEntityTable(XML_Parser oldParser,
|
||||||
|
HASH_TABLE *newTable,
|
||||||
STRING_POOL *newPool,
|
STRING_POOL *newPool,
|
||||||
const HASH_TABLE *oldTable)
|
const HASH_TABLE *oldTable)
|
||||||
{
|
{
|
||||||
@ -5792,7 +5902,7 @@ copyEntityTable(HASH_TABLE *newTable,
|
|||||||
name = poolCopyString(newPool, oldE->name);
|
name = poolCopyString(newPool, oldE->name);
|
||||||
if (!name)
|
if (!name)
|
||||||
return 0;
|
return 0;
|
||||||
newE = (ENTITY *)lookup(newTable, name, sizeof(ENTITY));
|
newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));
|
||||||
if (!newE)
|
if (!newE)
|
||||||
return 0;
|
return 0;
|
||||||
if (oldE->systemId) {
|
if (oldE->systemId) {
|
||||||
@ -5850,16 +5960,16 @@ keyeq(KEY s1, KEY s2)
|
|||||||
}
|
}
|
||||||
|
|
||||||
static unsigned long FASTCALL
|
static unsigned long FASTCALL
|
||||||
hash(KEY s)
|
hash(XML_Parser parser, KEY s)
|
||||||
{
|
{
|
||||||
unsigned long h = 0;
|
unsigned long h = hash_secret_salt;
|
||||||
while (*s)
|
while (*s)
|
||||||
h = CHAR_HASH(h, *s++);
|
h = CHAR_HASH(h, *s++);
|
||||||
return h;
|
return h;
|
||||||
}
|
}
|
||||||
|
|
||||||
static NAMED *
|
static NAMED *
|
||||||
lookup(HASH_TABLE *table, KEY name, size_t createSize)
|
lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize)
|
||||||
{
|
{
|
||||||
size_t i;
|
size_t i;
|
||||||
if (table->size == 0) {
|
if (table->size == 0) {
|
||||||
@ -5876,10 +5986,10 @@ lookup(HASH_TABLE *table, KEY name, size_t createSize)
|
|||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
memset(table->v, 0, tsize);
|
memset(table->v, 0, tsize);
|
||||||
i = hash(name) & ((unsigned long)table->size - 1);
|
i = hash(parser, name) & ((unsigned long)table->size - 1);
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
unsigned long h = hash(name);
|
unsigned long h = hash(parser, name);
|
||||||
unsigned long mask = (unsigned long)table->size - 1;
|
unsigned long mask = (unsigned long)table->size - 1;
|
||||||
unsigned char step = 0;
|
unsigned char step = 0;
|
||||||
i = h & mask;
|
i = h & mask;
|
||||||
@ -5905,7 +6015,7 @@ lookup(HASH_TABLE *table, KEY name, size_t createSize)
|
|||||||
memset(newV, 0, tsize);
|
memset(newV, 0, tsize);
|
||||||
for (i = 0; i < table->size; i++)
|
for (i = 0; i < table->size; i++)
|
||||||
if (table->v[i]) {
|
if (table->v[i]) {
|
||||||
unsigned long newHash = hash(table->v[i]->name);
|
unsigned long newHash = hash(parser, table->v[i]->name);
|
||||||
size_t j = newHash & newMask;
|
size_t j = newHash & newMask;
|
||||||
step = 0;
|
step = 0;
|
||||||
while (newV[j]) {
|
while (newV[j]) {
|
||||||
@ -6126,12 +6236,13 @@ poolGrow(STRING_POOL *pool)
|
|||||||
}
|
}
|
||||||
if (pool->blocks && pool->start == pool->blocks->s) {
|
if (pool->blocks && pool->start == pool->blocks->s) {
|
||||||
int blockSize = (int)(pool->end - pool->start)*2;
|
int blockSize = (int)(pool->end - pool->start)*2;
|
||||||
pool->blocks = (BLOCK *)
|
BLOCK *temp = (BLOCK *)
|
||||||
pool->mem->realloc_fcn(pool->blocks,
|
pool->mem->realloc_fcn(pool->blocks,
|
||||||
(offsetof(BLOCK, s)
|
(offsetof(BLOCK, s)
|
||||||
+ blockSize * sizeof(XML_Char)));
|
+ blockSize * sizeof(XML_Char)));
|
||||||
if (pool->blocks == NULL)
|
if (temp == NULL)
|
||||||
return XML_FALSE;
|
return XML_FALSE;
|
||||||
|
pool->blocks = temp;
|
||||||
pool->blocks->size = blockSize;
|
pool->blocks->size = blockSize;
|
||||||
pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
|
pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
|
||||||
pool->start = pool->blocks->s;
|
pool->start = pool->blocks->s;
|
||||||
@ -6280,7 +6391,7 @@ getElementType(XML_Parser parser,
|
|||||||
|
|
||||||
if (!name)
|
if (!name)
|
||||||
return NULL;
|
return NULL;
|
||||||
ret = (ELEMENT_TYPE *) lookup(&dtd->elementTypes, name, sizeof(ELEMENT_TYPE));
|
ret = (ELEMENT_TYPE *) lookup(parser, &dtd->elementTypes, name, sizeof(ELEMENT_TYPE));
|
||||||
if (!ret)
|
if (!ret)
|
||||||
return NULL;
|
return NULL;
|
||||||
if (ret->name != name)
|
if (ret->name != name)
|
||||||
|
@ -8,7 +8,7 @@
|
|||||||
#include "winconfig.h"
|
#include "winconfig.h"
|
||||||
#elif defined(MACOS_CLASSIC)
|
#elif defined(MACOS_CLASSIC)
|
||||||
#include "macconfig.h"
|
#include "macconfig.h"
|
||||||
#elif defined(__amigaos4__)
|
#elif defined(__amigaos__)
|
||||||
#include "amigaconfig.h"
|
#include "amigaconfig.h"
|
||||||
#elif defined(__WATCOMC__)
|
#elif defined(__WATCOMC__)
|
||||||
#include "watcomconfig.h"
|
#include "watcomconfig.h"
|
||||||
@ -199,10 +199,6 @@ prolog2(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_NONE;
|
return XML_ROLE_NONE;
|
||||||
@ -224,10 +220,6 @@ doctype0(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_DOCTYPE_NONE;
|
return XML_ROLE_DOCTYPE_NONE;
|
||||||
@ -276,10 +268,6 @@ doctype2(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_DOCTYPE_NONE;
|
return XML_ROLE_DOCTYPE_NONE;
|
||||||
@ -297,10 +285,6 @@ doctype3(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_DOCTYPE_NONE;
|
return XML_ROLE_DOCTYPE_NONE;
|
||||||
@ -318,10 +302,6 @@ doctype4(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_DOCTYPE_NONE;
|
return XML_ROLE_DOCTYPE_NONE;
|
||||||
@ -342,10 +322,6 @@ doctype5(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_DOCTYPE_NONE;
|
return XML_ROLE_DOCTYPE_NONE;
|
||||||
@ -465,10 +441,6 @@ entity0(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ENTITY_NONE;
|
return XML_ROLE_ENTITY_NONE;
|
||||||
@ -489,10 +461,6 @@ entity1(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ENTITY_NONE;
|
return XML_ROLE_ENTITY_NONE;
|
||||||
@ -538,10 +506,6 @@ entity3(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ENTITY_NONE;
|
return XML_ROLE_ENTITY_NONE;
|
||||||
@ -559,10 +523,6 @@ entity4(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ENTITY_NONE;
|
return XML_ROLE_ENTITY_NONE;
|
||||||
@ -603,10 +563,6 @@ entity6(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ENTITY_NONE;
|
return XML_ROLE_ENTITY_NONE;
|
||||||
@ -653,10 +609,6 @@ entity8(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ENTITY_NONE;
|
return XML_ROLE_ENTITY_NONE;
|
||||||
@ -674,10 +626,6 @@ entity9(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ENTITY_NONE;
|
return XML_ROLE_ENTITY_NONE;
|
||||||
@ -695,10 +643,6 @@ entity10(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ENTITY_NONE;
|
return XML_ROLE_ENTITY_NONE;
|
||||||
@ -716,10 +660,6 @@ notation0(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_NOTATION_NONE;
|
return XML_ROLE_NOTATION_NONE;
|
||||||
@ -761,10 +701,6 @@ notation2(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_NOTATION_NONE;
|
return XML_ROLE_NOTATION_NONE;
|
||||||
@ -782,10 +718,6 @@ notation3(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_NOTATION_NONE;
|
return XML_ROLE_NOTATION_NONE;
|
||||||
@ -804,10 +736,6 @@ notation4(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_NOTATION_NONE;
|
return XML_ROLE_NOTATION_NONE;
|
||||||
@ -829,10 +757,6 @@ attlist0(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ATTLIST_NONE;
|
return XML_ROLE_ATTLIST_NONE;
|
||||||
@ -851,10 +775,6 @@ attlist1(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ATTLIST_NONE;
|
return XML_ROLE_ATTLIST_NONE;
|
||||||
@ -917,10 +837,6 @@ attlist3(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ATTLIST_NONE;
|
return XML_ROLE_ATTLIST_NONE;
|
||||||
@ -940,10 +856,6 @@ attlist4(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ATTLIST_NONE;
|
return XML_ROLE_ATTLIST_NONE;
|
||||||
@ -964,10 +876,6 @@ attlist5(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ATTLIST_NONE;
|
return XML_ROLE_ATTLIST_NONE;
|
||||||
@ -985,10 +893,6 @@ attlist6(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ATTLIST_NONE;
|
return XML_ROLE_ATTLIST_NONE;
|
||||||
@ -1006,10 +910,6 @@ attlist7(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ATTLIST_NONE;
|
return XML_ROLE_ATTLIST_NONE;
|
||||||
@ -1071,10 +971,6 @@ attlist9(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ATTLIST_NONE;
|
return XML_ROLE_ATTLIST_NONE;
|
||||||
@ -1092,10 +988,6 @@ element0(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ELEMENT_NONE;
|
return XML_ROLE_ELEMENT_NONE;
|
||||||
@ -1184,10 +1076,6 @@ element3(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ELEMENT_NONE;
|
return XML_ROLE_ELEMENT_NONE;
|
||||||
@ -1213,10 +1101,6 @@ element4(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ELEMENT_NONE;
|
return XML_ROLE_ELEMENT_NONE;
|
||||||
@ -1235,10 +1119,6 @@ element5(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ELEMENT_NONE;
|
return XML_ROLE_ELEMENT_NONE;
|
||||||
@ -1260,10 +1140,6 @@ element6(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ELEMENT_NONE;
|
return XML_ROLE_ELEMENT_NONE;
|
||||||
@ -1294,10 +1170,6 @@ element7(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_ELEMENT_NONE;
|
return XML_ROLE_ELEMENT_NONE;
|
||||||
@ -1372,10 +1244,6 @@ condSect1(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_NONE;
|
return XML_ROLE_NONE;
|
||||||
@ -1394,10 +1262,6 @@ condSect2(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return XML_ROLE_NONE;
|
return XML_ROLE_NONE;
|
||||||
@ -1417,10 +1281,6 @@ declClose(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch (tok) {
|
switch (tok) {
|
||||||
case XML_TOK_PROLOG_S:
|
case XML_TOK_PROLOG_S:
|
||||||
return state->role_none;
|
return state->role_none;
|
||||||
@ -1438,12 +1298,6 @@ error(PROLOG_STATE *state,
|
|||||||
const char *end,
|
const char *end,
|
||||||
const ENCODING *enc)
|
const ENCODING *enc)
|
||||||
{
|
{
|
||||||
(void)state;
|
|
||||||
(void)tok;
|
|
||||||
(void)ptr;
|
|
||||||
(void)end;
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
return XML_ROLE_NONE;
|
return XML_ROLE_NONE;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -8,7 +8,7 @@
|
|||||||
#include "winconfig.h"
|
#include "winconfig.h"
|
||||||
#elif defined(MACOS_CLASSIC)
|
#elif defined(MACOS_CLASSIC)
|
||||||
#include "macconfig.h"
|
#include "macconfig.h"
|
||||||
#elif defined(__amigaos4__)
|
#elif defined(__amigaos__)
|
||||||
#include "amigaconfig.h"
|
#include "amigaconfig.h"
|
||||||
#elif defined(__WATCOMC__)
|
#elif defined(__WATCOMC__)
|
||||||
#include "watcomconfig.h"
|
#include "watcomconfig.h"
|
||||||
@ -124,25 +124,18 @@
|
|||||||
static int PTRFASTCALL
|
static int PTRFASTCALL
|
||||||
isNever(const ENCODING *enc, const char *p)
|
isNever(const ENCODING *enc, const char *p)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
(void)p;
|
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int PTRFASTCALL
|
static int PTRFASTCALL
|
||||||
utf8_isName2(const ENCODING *enc, const char *p)
|
utf8_isName2(const ENCODING *enc, const char *p)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
|
return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int PTRFASTCALL
|
static int PTRFASTCALL
|
||||||
utf8_isName3(const ENCODING *enc, const char *p)
|
utf8_isName3(const ENCODING *enc, const char *p)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
|
return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -151,16 +144,12 @@ utf8_isName3(const ENCODING *enc, const char *p)
|
|||||||
static int PTRFASTCALL
|
static int PTRFASTCALL
|
||||||
utf8_isNmstrt2(const ENCODING *enc, const char *p)
|
utf8_isNmstrt2(const ENCODING *enc, const char *p)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
|
return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int PTRFASTCALL
|
static int PTRFASTCALL
|
||||||
utf8_isNmstrt3(const ENCODING *enc, const char *p)
|
utf8_isNmstrt3(const ENCODING *enc, const char *p)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
|
return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -169,24 +158,18 @@ utf8_isNmstrt3(const ENCODING *enc, const char *p)
|
|||||||
static int PTRFASTCALL
|
static int PTRFASTCALL
|
||||||
utf8_isInvalid2(const ENCODING *enc, const char *p)
|
utf8_isInvalid2(const ENCODING *enc, const char *p)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
return UTF8_INVALID2((const unsigned char *)p);
|
return UTF8_INVALID2((const unsigned char *)p);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int PTRFASTCALL
|
static int PTRFASTCALL
|
||||||
utf8_isInvalid3(const ENCODING *enc, const char *p)
|
utf8_isInvalid3(const ENCODING *enc, const char *p)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
return UTF8_INVALID3((const unsigned char *)p);
|
return UTF8_INVALID3((const unsigned char *)p);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int PTRFASTCALL
|
static int PTRFASTCALL
|
||||||
utf8_isInvalid4(const ENCODING *enc, const char *p)
|
utf8_isInvalid4(const ENCODING *enc, const char *p)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
return UTF8_INVALID4((const unsigned char *)p);
|
return UTF8_INVALID4((const unsigned char *)p);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -253,7 +236,7 @@ static int FASTCALL checkCharRefNumber(int);
|
|||||||
#define MINBPC(enc) ((enc)->minBytesPerChar)
|
#define MINBPC(enc) ((enc)->minBytesPerChar)
|
||||||
#else
|
#else
|
||||||
/* minimum bytes per character */
|
/* minimum bytes per character */
|
||||||
#define MINBPC(enc) (((int)(enc) & 0) + 1)
|
#define MINBPC(enc) 1
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define SB_BYTE_TYPE(enc, p) \
|
#define SB_BYTE_TYPE(enc, p) \
|
||||||
@ -296,8 +279,8 @@ sb_byteToAscii(const ENCODING *enc, const char *p)
|
|||||||
#define IS_NMSTRT_CHAR_MINBPC(enc, p) \
|
#define IS_NMSTRT_CHAR_MINBPC(enc, p) \
|
||||||
(AS_NORMAL_ENCODING(enc)->isNmstrtMin(enc, p))
|
(AS_NORMAL_ENCODING(enc)->isNmstrtMin(enc, p))
|
||||||
#else
|
#else
|
||||||
#define IS_NAME_CHAR_MINBPC(enc, p) ((int)(enc) & 0)
|
#define IS_NAME_CHAR_MINBPC(enc, p) (0)
|
||||||
#define IS_NMSTRT_CHAR_MINBPC(enc, p) ((int)(enc) & 0)
|
#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef XML_MIN_SIZE
|
#ifdef XML_MIN_SIZE
|
||||||
@ -342,9 +325,6 @@ utf8_toUtf8(const ENCODING *enc,
|
|||||||
{
|
{
|
||||||
char *to;
|
char *to;
|
||||||
const char *from;
|
const char *from;
|
||||||
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
if (fromLim - *fromP > toLim - *toP) {
|
if (fromLim - *fromP > toLim - *toP) {
|
||||||
/* Avoid copying partial characters. */
|
/* Avoid copying partial characters. */
|
||||||
for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--)
|
for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--)
|
||||||
@ -450,8 +430,6 @@ latin1_toUtf8(const ENCODING *enc,
|
|||||||
const char **fromP, const char *fromLim,
|
const char **fromP, const char *fromLim,
|
||||||
char **toP, const char *toLim)
|
char **toP, const char *toLim)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
for (;;) {
|
for (;;) {
|
||||||
unsigned char c;
|
unsigned char c;
|
||||||
if (*fromP == fromLim)
|
if (*fromP == fromLim)
|
||||||
@ -477,8 +455,6 @@ latin1_toUtf16(const ENCODING *enc,
|
|||||||
const char **fromP, const char *fromLim,
|
const char **fromP, const char *fromLim,
|
||||||
unsigned short **toP, const unsigned short *toLim)
|
unsigned short **toP, const unsigned short *toLim)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
while (*fromP != fromLim && *toP != toLim)
|
while (*fromP != fromLim && *toP != toLim)
|
||||||
*(*toP)++ = (unsigned char)*(*fromP)++;
|
*(*toP)++ = (unsigned char)*(*fromP)++;
|
||||||
}
|
}
|
||||||
@ -512,8 +488,6 @@ ascii_toUtf8(const ENCODING *enc,
|
|||||||
const char **fromP, const char *fromLim,
|
const char **fromP, const char *fromLim,
|
||||||
char **toP, const char *toLim)
|
char **toP, const char *toLim)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
while (*fromP != fromLim && *toP != toLim)
|
while (*fromP != fromLim && *toP != toLim)
|
||||||
*(*toP)++ = *(*fromP)++;
|
*(*toP)++ = *(*fromP)++;
|
||||||
}
|
}
|
||||||
@ -568,9 +542,6 @@ E ## toUtf8(const ENCODING *enc, \
|
|||||||
char **toP, const char *toLim) \
|
char **toP, const char *toLim) \
|
||||||
{ \
|
{ \
|
||||||
const char *from; \
|
const char *from; \
|
||||||
\
|
|
||||||
(void)enc; \
|
|
||||||
\
|
|
||||||
for (from = *fromP; from != fromLim; from += 2) { \
|
for (from = *fromP; from != fromLim; from += 2) { \
|
||||||
int plane; \
|
int plane; \
|
||||||
unsigned char lo2; \
|
unsigned char lo2; \
|
||||||
@ -612,7 +583,7 @@ E ## toUtf8(const ENCODING *enc, \
|
|||||||
return; \
|
return; \
|
||||||
} \
|
} \
|
||||||
plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \
|
plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \
|
||||||
*(*toP)++ = (((char)((plane >> 2) & 0xff)) | UTF8_cval4); \
|
*(*toP)++ = ((plane >> 2) | UTF8_cval4); \
|
||||||
*(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80); \
|
*(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80); \
|
||||||
from += 2; \
|
from += 2; \
|
||||||
lo2 = GET_LO(from); \
|
lo2 = GET_LO(from); \
|
||||||
@ -633,8 +604,6 @@ E ## toUtf16(const ENCODING *enc, \
|
|||||||
const char **fromP, const char *fromLim, \
|
const char **fromP, const char *fromLim, \
|
||||||
unsigned short **toP, const unsigned short *toLim) \
|
unsigned short **toP, const unsigned short *toLim) \
|
||||||
{ \
|
{ \
|
||||||
(void)enc; \
|
|
||||||
\
|
|
||||||
/* Avoid copying first half only of surrogate */ \
|
/* Avoid copying first half only of surrogate */ \
|
||||||
if (fromLim - *fromP > ((toLim - *toP) << 1) \
|
if (fromLim - *fromP > ((toLim - *toP) << 1) \
|
||||||
&& (GET_HI(fromLim - 2) & 0xF8) == 0xD8) \
|
&& (GET_HI(fromLim - 2) & 0xF8) == 0xD8) \
|
||||||
@ -717,14 +686,14 @@ little2_isNmstrtMin(const ENCODING *enc, const char *p)
|
|||||||
|
|
||||||
#undef PREFIX
|
#undef PREFIX
|
||||||
#define PREFIX(ident) little2_ ## ident
|
#define PREFIX(ident) little2_ ## ident
|
||||||
#define MINBPC(enc) (((int)(enc) & 0) + 2)
|
#define MINBPC(enc) 2
|
||||||
/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
|
/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
|
||||||
#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
|
#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
|
||||||
#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(enc, p)
|
#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(enc, p)
|
||||||
#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(enc, p, c)
|
#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(enc, p, c)
|
||||||
#define IS_NAME_CHAR(enc, p, n) ((int)(enc) & 0)
|
#define IS_NAME_CHAR(enc, p, n) 0
|
||||||
#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(enc, p)
|
#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(enc, p)
|
||||||
#define IS_NMSTRT_CHAR(enc, p, n) ((int)(enc) & 0)
|
#define IS_NMSTRT_CHAR(enc, p, n) (0)
|
||||||
#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p)
|
#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p)
|
||||||
|
|
||||||
#define XML_TOK_IMPL_C
|
#define XML_TOK_IMPL_C
|
||||||
@ -858,14 +827,14 @@ big2_isNmstrtMin(const ENCODING *enc, const char *p)
|
|||||||
|
|
||||||
#undef PREFIX
|
#undef PREFIX
|
||||||
#define PREFIX(ident) big2_ ## ident
|
#define PREFIX(ident) big2_ ## ident
|
||||||
#define MINBPC(enc) (((int)(enc) & 0) + 2)
|
#define MINBPC(enc) 2
|
||||||
/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
|
/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
|
||||||
#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
|
#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
|
||||||
#define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(enc, p)
|
#define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(enc, p)
|
||||||
#define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(enc, p, c)
|
#define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(enc, p, c)
|
||||||
#define IS_NAME_CHAR(enc, p, n) ((int)(enc) & 0)
|
#define IS_NAME_CHAR(enc, p, n) 0
|
||||||
#define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(enc, p)
|
#define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(enc, p)
|
||||||
#define IS_NMSTRT_CHAR(enc, p, n) ((int)(enc) & 0)
|
#define IS_NMSTRT_CHAR(enc, p, n) (0)
|
||||||
#define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p)
|
#define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p)
|
||||||
|
|
||||||
#define XML_TOK_IMPL_C
|
#define XML_TOK_IMPL_C
|
||||||
@ -972,8 +941,6 @@ static void PTRCALL
|
|||||||
initUpdatePosition(const ENCODING *enc, const char *ptr,
|
initUpdatePosition(const ENCODING *enc, const char *ptr,
|
||||||
const char *end, POSITION *pos)
|
const char *end, POSITION *pos)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
|
normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -6,7 +6,7 @@
|
|||||||
#ifdef XML_TOK_IMPL_C
|
#ifdef XML_TOK_IMPL_C
|
||||||
|
|
||||||
#ifndef IS_INVALID_CHAR
|
#ifndef IS_INVALID_CHAR
|
||||||
#define IS_INVALID_CHAR(enc, ptr, n) ((int)(enc) & 0)
|
#define IS_INVALID_CHAR(enc, ptr, n) (0)
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
|
#define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
|
||||||
@ -179,9 +179,6 @@ PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr,
|
|||||||
const char *end, int *tokPtr)
|
const char *end, int *tokPtr)
|
||||||
{
|
{
|
||||||
int upper = 0;
|
int upper = 0;
|
||||||
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
*tokPtr = XML_TOK_PI;
|
*tokPtr = XML_TOK_PI;
|
||||||
if (end - ptr != MINBPC(enc)*3)
|
if (end - ptr != MINBPC(enc)*3)
|
||||||
return 1;
|
return 1;
|
||||||
@ -291,9 +288,6 @@ PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr,
|
|||||||
static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A,
|
static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A,
|
||||||
ASCII_T, ASCII_A, ASCII_LSQB };
|
ASCII_T, ASCII_A, ASCII_LSQB };
|
||||||
int i;
|
int i;
|
||||||
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
/* CDATA[ */
|
/* CDATA[ */
|
||||||
if (end - ptr < 6 * MINBPC(enc))
|
if (end - ptr < 6 * MINBPC(enc))
|
||||||
return XML_TOK_PARTIAL;
|
return XML_TOK_PARTIAL;
|
||||||
@ -891,7 +885,7 @@ PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
|
|||||||
const char **nextTokPtr)
|
const char **nextTokPtr)
|
||||||
{
|
{
|
||||||
if (ptr == end)
|
if (ptr == end)
|
||||||
return -XML_TOK_PERCENT;
|
return XML_TOK_PARTIAL;
|
||||||
switch (BYTE_TYPE(enc, ptr)) {
|
switch (BYTE_TYPE(enc, ptr)) {
|
||||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||||
case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
|
case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
|
||||||
@ -1530,9 +1524,6 @@ static int PTRFASTCALL
|
|||||||
PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
|
PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
|
||||||
{
|
{
|
||||||
int result = 0;
|
int result = 0;
|
||||||
|
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
/* skip &# */
|
/* skip &# */
|
||||||
ptr += 2*MINBPC(enc);
|
ptr += 2*MINBPC(enc);
|
||||||
if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
|
if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
|
||||||
@ -1577,8 +1568,6 @@ static int PTRCALL
|
|||||||
PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
|
PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
|
||||||
const char *end)
|
const char *end)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
switch ((end - ptr)/MINBPC(enc)) {
|
switch ((end - ptr)/MINBPC(enc)) {
|
||||||
case 2:
|
case 2:
|
||||||
if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
|
if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
|
||||||
@ -1697,8 +1686,6 @@ static int PTRCALL
|
|||||||
PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
|
PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
|
||||||
const char *end1, const char *ptr2)
|
const char *end1, const char *ptr2)
|
||||||
{
|
{
|
||||||
(void)enc;
|
|
||||||
|
|
||||||
for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
|
for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
|
||||||
if (ptr1 == end1)
|
if (ptr1 == end1)
|
||||||
return 0;
|
return 0;
|
||||||
@ -1757,7 +1744,7 @@ PREFIX(updatePosition)(const ENCODING *enc,
|
|||||||
const char *end,
|
const char *end,
|
||||||
POSITION *pos)
|
POSITION *pos)
|
||||||
{
|
{
|
||||||
while (ptr != end) {
|
while (ptr < end) {
|
||||||
switch (BYTE_TYPE(enc, ptr)) {
|
switch (BYTE_TYPE(enc, ptr)) {
|
||||||
#define LEAD_CASE(n) \
|
#define LEAD_CASE(n) \
|
||||||
case BT_LEAD ## n: \
|
case BT_LEAD ## n: \
|
||||||
@ -1793,8 +1780,4 @@ PREFIX(updatePosition)(const ENCODING *enc,
|
|||||||
#undef CHECK_NMSTRT_CASE
|
#undef CHECK_NMSTRT_CASE
|
||||||
#undef CHECK_NMSTRT_CASES
|
#undef CHECK_NMSTRT_CASES
|
||||||
|
|
||||||
#else /* XML_TOK_IMPL_C */
|
|
||||||
|
|
||||||
int xml_tok_impl_c;
|
|
||||||
|
|
||||||
#endif /* XML_TOK_IMPL_C */
|
#endif /* XML_TOK_IMPL_C */
|
||||||
|
@ -112,8 +112,4 @@ NS(XmlParseXmlDecl)(int isGeneralTextEntity,
|
|||||||
standalone);
|
standalone);
|
||||||
}
|
}
|
||||||
|
|
||||||
#else /* XML_TOK_NS_C */
|
|
||||||
|
|
||||||
int xml_tok_ns_c;
|
|
||||||
|
|
||||||
#endif /* XML_TOK_NS_C */
|
#endif /* XML_TOK_NS_C */
|
||||||
|
Loading…
Reference in New Issue
Block a user