//=============================================================================
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);
}
// 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);
}
static void XMLCALL
start_ns_clearing_start_element(void *userData,
const XML_Char *prefix,
const XML_Char *uri)
{
XML_SetStartElementHandler((XML_Parser) userData, NULL);
}
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;
}
XmlEncodingSpy::XmlEncodingSpy ( const char *encoding )
: WrapExpat ( encoding )
, d ( new EncodingData() )
{
XML_SetUserData ( p, d.get() );
XML_SetXmlDeclHandler ( p, xmldeclhandler );
XML_SetStartElementHandler ( p, start );
d->p = p;
}
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);
}
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.";
}
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;
}
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;
}
static void
run_attribute_check(XML_Char *text, XML_Char *expected)
{
CharData storage;
CharData_Init(&storage);
XML_SetUserData(parser, &storage);
XML_SetStartElementHandler(parser, accumulate_attribute);
if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR)
xml_failure(parser);
CharData_CheckXMLChars(&storage, expected);
}
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);
};
static void
_run_attribute_check(XML_Char *text, XML_Char *expected,
const char *file, int line)
{
CharData storage;
CharData_Init(&storage);
XML_SetUserData(parser, &storage);
XML_SetStartElementHandler(parser, accumulate_attribute);
if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
_xml_failure(parser, file, line);
CharData_CheckXMLChars(&storage, expected);
}
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);
}
static void init_parser(struct xmpp_parser *parser, bool is_stream_start) {
XML_SetReturnNSTriplet(parser->parser, true);
XML_SetElementHandler(parser->parser, start, end);
XML_SetCharacterDataHandler(parser->parser, chardata);
XML_SetUserData(parser->parser, parser);
XML_SetStartNamespaceDeclHandler(parser->parser, ns_start);
/* Inhibit the expansion of any external entities. */
XML_SetParamEntityParsing(parser->parser, XML_PARAM_ENTITY_PARSING_NEVER);
parser->needs_reset = false;
if (is_stream_start) {
XML_SetStartElementHandler(parser->parser, stream_start);
}
}
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 void
parse_position(Eina_List **cache, const char *filename, const char *state_file)
{
dbg("Checking current position of %s", filename);
int fd = open(state_file, O_RDONLY);
if (fd == -1)
return;
XML_Parser parser = XML_ParserCreate(NULL);
XML_SetStartElementHandler(parser, _start_element);
_context_t ctx = { .cache = cache, .filename = NULL, .parser = parser };
XML_SetUserData(parser, &ctx);
dbg("Parsing");
char buffer[4096];
for (;;)
{
int read_ = read(fd, buffer, 4096);
dbg("Read %d bytes from state.xml: %.*s", read_, read_, buffer);
if (read_ < 0)
{
dbg("Got error %s", strerror(errno));
if (errno == EINTR || errno == EAGAIN)
continue;
else
break;
}
else
{
int res = XML_Parse(parser, buffer, read_, read_ == 0);
dbg("Got %d (%d: %s, %d:%d) from XML_Parse", res, XML_GetErrorCode(parser),
XML_ErrorString(XML_GetErrorCode(parser)),
XML_GetCurrentLineNumber(parser),
XML_GetCurrentColumnNumber(parser));
if (read_ == 0 || res == XML_STATUS_ERROR)
break;
}
}
close(fd);
}
int
xps_parse_metadata(xps_context_t *ctx, xps_part_t *part)
{
XML_Parser xp;
int code;
char buf[1024];
char *s;
/* Save directory name part */
xps_strlcpy(buf, part->name, sizeof buf);
s = strrchr(buf, '/');
if (s)
s[0] = 0;
/* _rels parts are voodoo: their URI references are from
* the part they are associated with, not the actual _rels
* part being parsed.
*/
s = strstr(buf, "/_rels");
if (s)
*s = 0;
ctx->base_uri = buf;
ctx->part_uri = part->name;
xp = XML_ParserCreate(NULL);
if (!xp)
return gs_throw(-1, "cannot create XML parser");
XML_SetUserData(xp, ctx);
XML_SetParamEntityParsing(xp, XML_PARAM_ENTITY_PARSING_NEVER);
XML_SetStartElementHandler(xp, (XML_StartElementHandler)xps_parse_metadata_imp);
code = XML_Parse(xp, (char*)part->data, part->size, 1);
XML_ParserFree(xp);
ctx->base_uri = NULL;
ctx->part_uri = NULL;
if (code == 0)
return gs_throw1(-1, "cannot parse XML in part: %s", part->name);
return 0;
}
core_state::core_state(const std::string& filename) {
if (access(filename.c_str(),R_OK)!=0)
throw core_exception("could not open status file "+filename);
FILE* configfile=fopen(filename.c_str(),"r");
/* parse document */
XML_Parser p=XML_ParserCreate(NULL);
/* set handler and user data*/
XML_SetStartElementHandler(p,(XML_StartElementHandler)&xml_core_status_startelement_handler);
XML_SetUserData(p,(void*)this);
/* read buffer */
for (;;) {
const size_t BUFF_SIZE=4000;
int bytes_read;
void *buff = XML_GetBuffer(p,BUFF_SIZE);
if (buff == NULL) {
/* handle error */
}
bytes_read = fread(buff, 1, BUFF_SIZE, configfile);
if (bytes_read < 0) {
fclose(configfile);
XML_ParserFree(p);
throw core_exception("error while reading file "+filename);
}
if (! XML_ParseBuffer(p, bytes_read, bytes_read == 0)) {
/* handle parse error */
fclose(configfile);
XML_ParserFree(p);
throw core_exception("error while parsing file "+filename);
}
if (bytes_read == 0)
break;
}
XML_ParserFree(p);
fclose(configfile);
}
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);
}
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;
}
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;
}
/** Expat callback for the start of an XMPP stream. */
static void stream_start(void *data, const char *ns_name, const char **attrs) {
struct xmpp_parser *parser = (struct xmpp_parser*)data;
struct xmpp_stanza *stanza = xmpp_stanza_ns_new(ns_name, attrs,
parser->namespaces);
#ifndef NDEBUG
char *str = xmpp_stanza_string(stanza, NULL, false);
debug("Handling Stanza: %s", str);
free(str);
#endif
parser->namespaces = NULL;
if (!parser->handler(stanza, parser, parser->data)) {
XML_StopParser(parser->parser, false);
} else {
parser->depth = 0;
XML_SetStartElementHandler(parser->parser, start);
}
xmpp_stanza_del(stanza, false);
}
void parse_conf() {
FILE *conf_file;
char *buffer;
XML_Parser p = XML_ParserCreate(NULL);
if ( (conf_file = fopen(CONF_FILE,"r")) == NULL ) {
perror("Error opening config file\n");
exit(1);
}
buffer = (char *)malloc(sizeof(char) * 1024);
XML_SetStartElementHandler(p,start_element);
while(1) {
int len,done;
len = fread(buffer,1,1024,conf_file);
if (ferror(conf_file)) {
perror("Error reading config file\n");
exit(1);
}
done = feof(conf_file);
if ( !XML_Parse(p,buffer,len,done) ) {
fprintf(stderr, "Parse error at line %d:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
exit(1);
}
if(done) break;
}
fclose(conf_file);
XML_ParserFree(p);
free(buffer);
}
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;
}
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);
}
