// restore parser handlers from previous one in stack
void XSD_RestoreStack(xml_parser_stack_t *stack)
{
XML_SetStartElementHandler(stack->parser, stack->oldStartHandler);
XML_SetEndElementHandler(stack->parser, stack->oldEndHandler);
XML_SetCharacterDataHandler(stack->parser, stack->oldCharacterDataHandler);
XML_SetUserData(stack->parser, stack->oldUserData);
}
void QTVList_Process_Full_List(vfsfile_t *f, sb_qtvlist_parse_state_t *sb_qtvparse)
{
XML_Parser parser = NULL;
int len;
enum XML_Status status;
char buf[4096];
vfserrno_t err;
// initialize XML parser
parser = XML_ParserCreate(NULL);
if (parser == NULL) {
Com_Printf("Couldn't initialize XML parser\n");
return;
}
XML_SetStartElementHandler(parser, QTVList_Parse_StartElement);
XML_SetCharacterDataHandler(parser, QTVList_Parse_CharacterData);
XML_SetEndElementHandler(parser, QTVList_Parse_EndElement);
XML_SetUserData(parser, (void *) sb_qtvparse);
while ((len = VFS_READ(f, buf, 4096, &err)) > 0)
{
if ((status = XML_Parse(parser, buf, len, 0)) != XML_STATUS_OK) {
enum XML_Error err = XML_GetErrorCode(parser);
Com_Printf("XML parser error.\n%s\n", status, XML_ErrorString(err));
break;
}
}
}
static int initializeExpat()
{
doc = XML_ParserCreate(NULL);
XML_SetStartElementHandler(doc,&starttag);
XML_SetEndElementHandler(doc,&endtag);
XML_SetCharacterDataHandler(doc,&texttag);
return 0;
}
XmlParser::XmlParser(XmlContentHandler& handler)
: handler_(handler)
{
parser_ = XML_ParserCreateNS(0, '\t');
XML_SetUserData(parser_, static_cast<void*>(this));
XML_SetStartElementHandler(parser_, StartElementHandler);
XML_SetEndElementHandler(parser_, EndElementHandler);
XML_SetCharacterDataHandler(parser_, CharacterDataHandler);
error_msg_ = "Failed to parse XML.";
}
void CeIdObject::GetParams(std::string strToParse)
{
XML_Parser parser = XML_ParserCreate(NULL);
XML_SetUserData(parser, (void *) this);
XML_SetStartElementHandler(parser, StartElementHandler);
XML_SetEndElementHandler(parser, EndElementHandler);
XML_SetCharacterDataHandler(parser, CharacterDataHandler);
XML_Parse(parser, strToParse.c_str(), strToParse.length(), true);
XML_ParserFree(parser);
}
xml_t * XSD_Variable_LoadFromHandle(FILE *f, int filelen) {
#else
xml_t * XSD_Variable_LoadFromHandle(vfsfile_t *v, int filelen) {
vfserrno_t err;
#endif
xml_variable_t *document;
XML_Parser parser = NULL;
int len;
int pos = 0;
char buf[XML_READ_BUFSIZE];
xml_parser_stack_t parser_stack;
// create blank document
document = (xml_variable_t *) Q_malloc(sizeof(xml_variable_t));
XSD_Variable_Init(document);
// initialize XML parser
parser = XML_ParserCreate(NULL);
if (parser == NULL)
goto error;
XML_SetStartElementHandler(parser, OnStartElement);
XML_SetEndElementHandler(parser, OnEndElement);
XML_SetCharacterDataHandler(parser, OnCharacterData);
// prepare user data
XSD_InitStack(&parser_stack);
parser_stack.document = (xml_t *) document;
XML_SetUserData(parser, &parser_stack);
#ifndef WITH_FTE_VFS
while ((len = fread(buf, 1, min(XML_READ_BUFSIZE, filelen-pos), f)) > 0)
#else
while ((len = VFS_READ(v, buf, min(XML_READ_BUFSIZE, filelen-pos), &err)) > 0)
#endif
{
if (XML_Parse(parser, buf, len, 0) != XML_STATUS_OK)
goto error;
pos += len;
}
if (XML_Parse(parser, NULL, 0, 1) != XML_STATUS_OK)
goto error;
XML_ParserFree(parser);
return (xml_t *) document;
error:
if (parser)
XML_ParserFree(parser);
XSD_Variable_Free((xml_t *)document);
return NULL;
}
int
main(int argc, char **argv)
{
XML_Parser parser;
size_t i;
size_t j;
nst_cfg_allocator = nst_mem_stat_register("NST CFG");
parser = XML_ParserCreate(NULL);
expat_stack_top->parser = parser;
if(!parser) {
assert(0 && "Cannot allocate memory during XML_ParserCreate\n");
return -1;
}
for(i = 0;
i < sizeof(xml_test_strings) / sizeof(const char *);
i++) {
const char *xml_test_string = xml_test_strings[i];
enum XML_Status xml_status;
XML_SetStartElementHandler(parser, root_start_handler);
XML_SetEndElementHandler(parser, root_end_handler);
XML_SetCharacterDataHandler(parser, root_char_handler);
XML_SetUserData(parser, (void*)&expat_stack_top);
for(j = 0; xml_test_string[j]; j++) {
xml_status = XML_Parse(parser, xml_test_string+j, 1, 0);
if(xml_status != XML_STATUS_OK) {
fprintf(stderr, "Parse error at line %lu: %s\n",
XML_GetCurrentLineNumber(parser),
XML_ErrorString(XML_GetErrorCode(parser)));
return -1;
}
}
xml_status = XML_Parse(parser, NULL, 0, 1);
if(xml_status != XML_STATUS_OK) {
fprintf(stderr, "Parse error at line %lu: %s\n",
XML_GetCurrentLineNumber(parser),
XML_ErrorString(XML_GetErrorCode(parser)));
return -1;
}
XML_ParserReset(parser, NULL);
};
XML_ParserFree(parser);
assert(nst_mem_stat_get_allocated_nbytes(nst_cfg_allocator.data) == 0);
return 0;
}
static void init_parser(XML_Parser parser, expat_parser *parser_data)
{
XML_SetUserData(parser, parser_data);
XML_SetStartElementHandler(parser, (XML_StartElementHandler)start_element_handler);
XML_SetEndElementHandler(parser, (XML_EndElementHandler)end_element_handler);
XML_SetCharacterDataHandler(parser, (XML_CharacterDataHandler)character_data_handler);
XML_SetStartNamespaceDeclHandler(parser, (XML_StartNamespaceDeclHandler)namespace_decl_handler);
XML_SetReturnNSTriplet(parser, 1);
XML_SetDefaultHandler(parser, NULL);
};
XML_Parser::XML_Parser()
{
_rep = new XML_Parser_Rep;
_rep->self = this;
_rep->error = false;
_rep->parser = XML_ParserCreate("UTF-8");
XML_SetUserData(_rep->parser, _rep);
XML_SetStartElementHandler(_rep->parser, _start_element_handler);
XML_SetEndElementHandler(_rep->parser, _end_element_handler);
XML_SetCharacterDataHandler(_rep->parser, _character_data_handler);
}
void
OMXMLReaderExpat::reset()
{
TRACE("OMXMLReaderExpat::reset");
XML_ParserFree(_parser);
if (_workBuffer != 0)
{
delete [] _workBuffer;
}
OMListIterator<OMXMLAttribute*> iter(_attributes, OMBefore);
while (++iter)
{
delete iter.value();
}
_attributes.clear();
OMUInt32 elementCount = _startNmspaceDecls.count();
for (OMUInt32 i = 0; i < elementCount; i++)
{
delete _startNmspaceDecls.getAt(i);
}
_startNmspaceDecls.clear();
_endNmspaceDecls.clear();
clearEvents();
_parser = XML_ParserCreateNS(0, NAMESPACE_SEPARATOR);
XML_SetNotationDeclHandler(_parser, ::expat_NotationDeclHandler);
XML_SetEntityDeclHandler(_parser, ::expat_EntityDeclHandler);
XML_SetStartNamespaceDeclHandler(_parser, ::expat_StartNamespaceDeclHandler);
XML_SetEndNamespaceDeclHandler(_parser, ::expat_EndNamespaceDeclHandler);
XML_SetStartElementHandler(_parser, ::expat_StartElementHandler);
XML_SetEndElementHandler(_parser, ::expat_EndElementHandler);
XML_SetCharacterDataHandler(_parser, ::expat_CharacterDataHandler);
XML_SetUserData(_parser, this);
_workBuffer = new wchar_t[WORK_BUFFER_MIN_SIZE];
_workBufferSize = WORK_BUFFER_MIN_SIZE;
_readNextChunk = true;
_status = true;
_numInBuffer = 0;
_xmlStream->setPosition(0);
}
//=============================================================================
bool CPdpManager::LoadFromXml(const string& fromFile )
{
//read the file into a buffer
ifstream fProj(fromFile.c_str());
if (!fProj.is_open())
return false;
fProj.seekg( 0, ios_base::end );
std::streamoff fileSize = fProj.tellg();
if (fileSize <= 0)
return false;
fProj.seekg( 0, ios_base::beg);
vector<char> fileBuff;
fileBuff.resize(fileSize);
fProj.read(&(fileBuff[0]), fileSize);
fProj.close();
//parse the file's xml
XML_Parser m_parser;
m_parser = XML_ParserCreate(0);
XML_SetUserData(m_parser, this);
XML_SetStartElementHandler(m_parser, StartElement);
XML_SetEndElementHandler(m_parser, EndElement);
// XML_SetCharacterDataHandler(m_parser, CharacterDataHandler);
// XML_SetCommentHandler(m_parser, CommentHandler);
int rtn = XML_Parse(m_parser, &(fileBuff[0]), fileBuff.size(), true);
if (!rtn)
{
dprintf("Error parsing:\n");
dprintf(XML_ErrorString(XML_GetErrorCode(m_parser)));
dprintf(" (line: %d, col: %d)\n", XML_GetCurrentLineNumber(m_parser), XML_GetCurrentColumnNumber(m_parser));
}
// XML_SetCommentHandler(m_parser, 0);
// XML_SetCharacterDataHandler(m_parser, 0);
// XML_SetEndElementHandler(m_parser, 0);
XML_SetStartElementHandler(m_parser, 0);
XML_SetUserData(m_parser, 0);
XML_ParserFree(m_parser);
return (rtn == 0);
}
bool_t reset_handlers_parser(parser_t *parser) {
if( parser ) {
XML_SetStartElementHandler(parser->p, parser->callbacks.start_tag ?
xml_startelementhandler : NULL);
XML_SetEndElementHandler(parser->p, parser->callbacks.end_tag ?
xml_endelementhandler : NULL);
XML_SetCommentHandler(parser->p, parser->callbacks.comment ?
xml_commenthandler : NULL);
XML_SetCharacterDataHandler(parser->p, parser->callbacks.chardata ?
xml_characterdatahandler : NULL);
XML_SetProcessingInstructionHandler(parser->p, parser->callbacks.pidata ?
xml_processinginstructionhandler : NULL);
XML_SetStartCdataSectionHandler(parser->p, parser->callbacks.start_cdata ?
xml_startcdatahandler : NULL);
/* if start_cdata, always set endcdatahandler */
XML_SetEndCdataSectionHandler(parser->p, parser->callbacks.start_cdata ?
xml_endcdatahandler : NULL);
XML_SetDefaultHandler(parser->p, parser->callbacks.dfault ?
xml_defaulthandler : NULL);
XML_SetStartDoctypeDeclHandler(parser->p, parser->callbacks.start_doctypedecl ?
xml_startdoctypedeclhandler : NULL);
/* if start_doctypedecl, always set enddoctypedeclhandler */
XML_SetEndDoctypeDeclHandler(parser->p, parser->callbacks.start_doctypedecl ?
xml_enddoctypedeclhandler : NULL);
XML_SetEntityDeclHandler(parser->p, parser->callbacks.entitydecl ?
xml_entitydeclhandler : NULL);
/* what to do about entities: there can be internal and external
* entities, which expat treats differently. We want all our
* entities to stay unprocessed, otherwise we'll get well formedness
* errors. When a handler is called, the raw string is passed to
* the default handler (provided it exists). */
XML_UseForeignDTD(parser->p, XML_TRUE);
XML_SetParamEntityParsing(parser->p, XML_PARAM_ENTITY_PARSING_NEVER);
XML_SetExternalEntityRefHandler(parser->p,
xml_externalentityrefhandler);
XML_SetExternalEntityRefHandlerArg(parser->p, parser);
XML_SetSkippedEntityHandler(parser->p, xml_skippedentityhandler);
return TRUE;
}
return FALSE;
}
static ErlDrvData expat_erl_start(ErlDrvPort port, char *buff)
{
expat_data* d = (expat_data*)driver_alloc(sizeof(expat_data));
d->port = port;
d->parser = XML_ParserCreate("UTF-8");
XML_SetUserData(d->parser, d);
set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
XML_SetStartElementHandler(
d->parser, (XML_StartElementHandler)erlXML_StartElementHandler);
XML_SetEndElementHandler(
d->parser, (XML_EndElementHandler)erlXML_EndElementHandler);
XML_SetCharacterDataHandler(
d->parser, (XML_CharacterDataHandler)erlXML_CharacterDataHandler);
return (ErlDrvData)d;
}
xps_item_t *
xps_parse_xml(xps_context_t *ctx, byte *buf, int len)
{
xps_parser_t parser;
XML_Parser xp;
int code;
parser.ctx = ctx;
parser.root = NULL;
parser.head = NULL;
parser.error = NULL;
parser.compat = 0;
xp = XML_ParserCreateNS(NULL, ' ');
if (!xp)
{
gs_throw(-1, "xml error: could not create expat parser");
return NULL;
}
XML_SetUserData(xp, &parser);
XML_SetParamEntityParsing(xp, XML_PARAM_ENTITY_PARSING_NEVER);
XML_SetStartElementHandler(xp, (XML_StartElementHandler)on_open_tag);
XML_SetEndElementHandler(xp, (XML_EndElementHandler)on_close_tag);
XML_SetCharacterDataHandler(xp, (XML_CharacterDataHandler)on_text);
code = XML_Parse(xp, (char*)buf, len, 1);
if (code == 0)
{
if (parser.root)
xps_free_item(ctx, parser.root);
XML_ParserFree(xp);
gs_throw1(-1, "xml error: %s", XML_ErrorString(XML_GetErrorCode(xp)));
return NULL;
}
XML_ParserFree(xp);
if (parser.compat)
xps_process_compatibility(ctx, parser.root);
return parser.root;
}
void ZLXMLReaderInternal::init(const char *encoding) {
if (myInitialized) {
XML_ParserReset(myParser, encoding);
}
myInitialized = true;
XML_UseForeignDTD(myParser, XML_TRUE);
setupEntities();
XML_SetUserData(myParser, &myReader);
if (encoding != 0) {
XML_SetEncoding(myParser, encoding);
}
XML_SetStartElementHandler(myParser, fStartElementHandler);
XML_SetEndElementHandler(myParser, fEndElementHandler);
XML_SetCharacterDataHandler(myParser, fCharacterDataHandler);
XML_SetUnknownEncodingHandler(myParser, fUnknownEncodingHandler, 0);
}
svg_status_t
_svg_parser_begin (svg_parser_t *parser)
{
/* Innocent until proven guilty */
parser->status = SVG_STATUS_SUCCESS;
if (parser->ctxt)
parser->status = SVG_STATUS_INVALID_CALL;
parser->ctxt = XML_ParserCreate (NULL);
XML_SetUserData (parser->ctxt, parser);
XML_SetStartElementHandler (parser->ctxt, _svg_parser_sax_start_element);
XML_SetEndElementHandler (parser->ctxt, _svg_parser_sax_end_element);
XML_SetCharacterDataHandler (parser->ctxt, _svg_parser_sax_characters);
if (parser->ctxt == NULL)
parser->status = SVG_STATUS_NO_MEMORY;
return parser->status;
}
void ZLXMLReaderInternal::init(const char *encoding) {
if (myInitialized) {
XML_ParserReset(myParser, encoding);
}
myInitialized = true;
XML_UseForeignDTD(myParser, XML_TRUE);
const std::vector<std::string> &dtds = myReader.externalDTDs();
for (std::vector<std::string>::const_iterator it = dtds.begin(); it != dtds.end(); ++it) {
myDTDStreamLocks.insert(ZLFile(*it).inputStream());
parseDTD(myParser, *it);
}
XML_SetUserData(myParser, &myReader);
if (encoding != 0) {
XML_SetEncoding(myParser, encoding);
}
XML_SetStartElementHandler(myParser, fStartElementHandler);
XML_SetEndElementHandler(myParser, fEndElementHandler);
XML_SetCharacterDataHandler(myParser, fCharacterDataHandler);
XML_SetUnknownEncodingHandler(myParser, fUnknownEncodingHandler, 0);
}
OMXMLReaderExpat::OMXMLReaderExpat(OMRawStorage* xmlStream)
: _appendData(false), _xmlStream(xmlStream), _parser(0)
{
TRACE("OMXMLReaderExpat::OMXMLReaderExpat");
clearEvents();
_parser = XML_ParserCreateNS(0, NAMESPACE_SEPARATOR);
XML_SetNotationDeclHandler(_parser, ::expat_NotationDeclHandler);
XML_SetEntityDeclHandler(_parser, ::expat_EntityDeclHandler);
XML_SetStartNamespaceDeclHandler(_parser, ::expat_StartNamespaceDeclHandler);
XML_SetEndNamespaceDeclHandler(_parser, ::expat_EndNamespaceDeclHandler);
XML_SetStartElementHandler(_parser, ::expat_StartElementHandler);
XML_SetEndElementHandler(_parser, ::expat_EndElementHandler);
XML_SetCharacterDataHandler(_parser, ::expat_CharacterDataHandler);
XML_SetUserData(_parser, this);
_workBuffer = new wchar_t[WORK_BUFFER_MIN_SIZE];
_workBufferSize = WORK_BUFFER_MIN_SIZE;
_readNextChunk = true;
_status = true;
_numInBuffer = 0;
}
static ErlDrvData expat_erl_start(ErlDrvPort port, char *buff)
{
expat_data* d = (expat_data*)driver_alloc(sizeof(expat_data));
d->port = port;
d->parser = XML_ParserCreate_MM("UTF-8", &ms, "\n");
XML_SetUserData(d->parser, d);
set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
XML_SetStartElementHandler(
d->parser, (XML_StartElementHandler)erlXML_StartElementHandler);
XML_SetEndElementHandler(
d->parser, (XML_EndElementHandler)erlXML_EndElementHandler);
XML_SetCharacterDataHandler(
d->parser, (XML_CharacterDataHandler)erlXML_CharacterDataHandler);
XML_SetStartNamespaceDeclHandler(
d->parser, (XML_StartNamespaceDeclHandler) erlXML_StartNamespaceDeclHandler);
XML_SetReturnNSTriplet(d->parser, 1);
XML_SetDefaultHandler(d->parser, NULL);
return (ErlDrvData)d;
}
END_TEST
/* Regression test #4 for SF bug #673791. */
START_TEST(test_ns_prefix_with_empty_uri_4)
{
char *text =
"<!DOCTYPE doc [\n"
" <!ELEMENT prefix:doc EMPTY>\n"
" <!ATTLIST prefix:doc\n"
" xmlns:prefix CDATA 'http://xml.libexpat.org/'>\n"
"]>\n"
"<prefix:doc/>";
/* Packaged info expected by the end element handler;
the weird structuring lets us re-use the triplet_end_checker()
function also used for another test. */
char *elemstr[] = {
"http://xml.libexpat.org/ doc prefix"
};
XML_SetReturnNSTriplet(parser, XML_TRUE);
XML_SetUserData(parser, elemstr);
XML_SetEndElementHandler(parser, triplet_end_checker);
if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
xml_failure(parser);
}
static void parseString(const char* xml, void* userData, bool addFakeRoot = false)
{
XML_Parser parser = XML_ParserCreate(NULL);
XML_SetUserData(parser, userData);
try {
int parsed = 1;
if (addFakeRoot)
{
XML_SetStartElementHandler(parser, NULL);
XML_SetEndElementHandler(parser, NULL);
XML_SetCharacterDataHandler(parser, NULL);
parsed = XML_Parse(parser, "<root>", 6, 0);
if (!parsed)
throw Exception();
}
XML_SetStartElementHandler(parser, startElement);
XML_SetEndElementHandler(parser, endElement);
XML_SetCharacterDataHandler(parser, characterData);
parsed = XML_Parse(parser, xml, strlen(xml), !addFakeRoot);
if (!parsed)
throw Exception();
if (addFakeRoot)
{
XML_SetStartElementHandler(parser, NULL);
XML_SetEndElementHandler(parser, NULL);
XML_SetCharacterDataHandler(parser, NULL);
parsed = XML_Parse(parser, "</root>", 7, 1);
if (!parsed)
throw Exception();
}
}
catch (Exception& ex)
{
XML_ParserFree(parser);
std::stringstream ss;
if (ex.hasMessage())
{
ss << ex.getMessage();
}
else
{
ss << "Error while parsing XML: ";
ss << XML_ErrorString(XML_GetErrorCode(parser));
}
ss << " at line ";
ss << XML_GetCurrentLineNumber(parser);
throw Exception(ss.str());
}
XML_ParserFree(parser);
}
static void parseFile(const char* fileName, void* userData, bool addFakeRoot = false)
{
XML_Parser parser = XML_ParserCreate(NULL);
XML_SetUserData(parser, userData);
try {
int parsed = 1;
if (addFakeRoot)
{
XML_SetStartElementHandler(parser, NULL);
XML_SetEndElementHandler(parser, NULL);
XML_SetCharacterDataHandler(parser, NULL);
parsed = XML_Parse(parser, "<root>", 6, 0);
if (!parsed)
throw Exception();
}
XML_SetStartElementHandler(parser, startElement);
XML_SetEndElementHandler(parser, endElement);
XML_SetCharacterDataHandler(parser, characterData);
FILE* f = fopen(fileName, "r");
if (f == NULL)
throw Exception(std::string("Could not open XML file '") + fileName + "'");
char line[1024];
while (parsed && !feof(f))
{
fgets(line, sizeof(line), f);
if (!feof(f))
{
parsed = XML_Parse(parser, line, strlen(line), 0);
if (!parsed)
throw Exception();
}
}
if (!addFakeRoot)
XML_Parse(parser, "", 0, 1);
fclose(f);
if (addFakeRoot)
{
XML_SetStartElementHandler(parser, NULL);
XML_SetEndElementHandler(parser, NULL);
XML_SetCharacterDataHandler(parser, NULL);
parsed = XML_Parse(parser, "</root>", 7, 1);
if (!parsed)
throw Exception();
}
}
catch (Exception& ex)
{
XML_ParserFree(parser);
std::stringstream ss;
if (ex.hasMessage())
{
ss << ex.getMessage();
}
else
{
ss << "Error while parsing XML: ";
ss << XML_ErrorString(XML_GetErrorCode(parser));
}
ss << " at line ";
ss << XML_GetCurrentLineNumber(parser);
ss << " in file ";
ss << fileName;
throw Exception(ss.str());
}
XML_ParserFree(parser);
}
void bmx_expat_XML_SetEndElementHandler(XML_Parser parser) {
XML_SetEndElementHandler(parser, bmx_expat_EndElementHandler);
}
void _Expat_XML_SetEndElementHandler(struct ExpatIFace * Self, XML_Parser parser, XML_EndElementHandler end)
{
XML_SetEndElementHandler(parser, end);
}
void XMLParser::EnableEndElementHandler(bool enable)
{
assert(m_parser != NULL);
XML_SetEndElementHandler(m_parser, enable ? EndElementHandler : NULL);
}