void ParserEngine::init()
{
if (_parser)
XML_ParserFree(_parser);
if (!_pBuffer)
_pBuffer = new char[PARSE_BUFFER_SIZE];
if (dynamic_cast<NoNamespacePrefixesStrategy*>(_pNamespaceStrategy))
{
_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
if (_parser)
{
XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
}
}
else if (dynamic_cast<NamespacePrefixesStrategy*>(_pNamespaceStrategy))
{
_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
if (_parser)
{
XML_SetReturnNSTriplet(_parser, 1);
XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
}
}
else
{
_parser = XML_ParserCreate(_encodingSpecified ? _encoding.c_str() : 0);
}
if (!_parser) throw XMLException("Cannot create Expat parser");
XML_SetUserData(_parser, this);
XML_SetElementHandler(_parser, handleStartElement, handleEndElement);
XML_SetCharacterDataHandler(_parser, handleCharacterData);
XML_SetProcessingInstructionHandler(_parser, handleProcessingInstruction);
if (_expandInternalEntities)
XML_SetDefaultHandlerExpand(_parser, handleDefault);
else
XML_SetDefaultHandler(_parser, handleDefault);
XML_SetUnparsedEntityDeclHandler(_parser, handleUnparsedEntityDecl);
XML_SetNotationDeclHandler(_parser, handleNotationDecl);
XML_SetExternalEntityRefHandler(_parser, handleExternalEntityRef);
XML_SetCommentHandler(_parser, handleComment);
XML_SetCdataSectionHandler(_parser, handleStartCdataSection, handleEndCdataSection);
XML_SetDoctypeDeclHandler(_parser, handleStartDoctypeDecl, handleEndDoctypeDecl);
XML_SetEntityDeclHandler(_parser, handleEntityDecl);
XML_SetSkippedEntityHandler(_parser, handleSkippedEntity);
XML_SetParamEntityParsing(_parser, _externalParameterEntities ? XML_PARAM_ENTITY_PARSING_ALWAYS : XML_PARAM_ENTITY_PARSING_NEVER);
XML_SetUnknownEncodingHandler(_parser, handleUnknownEncoding, this);
}
struct caldav *
caldav_parse(const char *buf, size_t sz)
{
struct parse p;
memset(&p, 0, sizeof(struct parse));
if (NULL == (p.xp = XML_ParserCreateNS(NULL, ':'))) {
kerr(NULL);
return(NULL);
}
bufappend(&p.buf, " ", 1);
XML_SetDefaultHandler(p.xp, NULL);
XML_SetElementHandler(p.xp, parseopen, parseclose);
XML_SetCdataSectionHandler(p.xp, cdata, cdata);
XML_SetUserData(p.xp, &p);
if (XML_STATUS_OK != XML_Parse(p.xp, buf, (int)sz, 1)) {
caldav_free(p.p);
p.p = NULL;
}
XML_ParserFree(p.xp);
free(p.buf.buf);
return(p.p);
}
ExpatAdapter::ExpatAdapter() : parser(0)
{
#if XMP_DebugBuild
this->elemNesting = 0;
#if DumpXMLParseEvents
if ( this->parseLog == 0 ) this->parseLog = stdout;
#endif
#endif
this->parser = XML_ParserCreateNS ( 0, FullNameSeparator );
if ( this->parser == 0 ) XMP_Throw ( "Failure creating Expat parser", kXMPErr_ExternalFailure );
XML_SetUserData ( this->parser, this );
XML_SetNamespaceDeclHandler ( this->parser, StartNamespaceDeclHandler, EndNamespaceDeclHandler );
XML_SetElementHandler ( this->parser, StartElementHandler, EndElementHandler );
XML_SetCharacterDataHandler ( this->parser, CharacterDataHandler );
XML_SetCdataSectionHandler ( this->parser, StartCdataSectionHandler, EndCdataSectionHandler );
XML_SetProcessingInstructionHandler ( this->parser, ProcessingInstructionHandler );
XML_SetCommentHandler ( this->parser, CommentHandler );
#if BanAllEntityUsage
XML_SetStartDoctypeDeclHandler ( this->parser, StartDoctypeDeclHandler );
isAborted = false;
#endif
this->parseStack.push_back ( &this->tree ); // Push the XML root node.
} // ExpatAdapter::ExpatAdapter
std::unique_ptr<Node> inflate(std::istream* in, SourceLogger* logger) {
Stack stack;
XML_Parser parser = XML_ParserCreateNS(nullptr, kXmlNamespaceSep);
XML_SetUserData(parser, &stack);
XML_UseParserAsHandlerArg(parser);
XML_SetElementHandler(parser, startElementHandler, endElementHandler);
XML_SetNamespaceDeclHandler(parser, startNamespaceHandler, endNamespaceHandler);
XML_SetCharacterDataHandler(parser, characterDataHandler);
XML_SetCommentHandler(parser, commentDataHandler);
char buffer[1024];
while (!in->eof()) {
in->read(buffer, sizeof(buffer) / sizeof(buffer[0]));
if (in->bad() && !in->eof()) {
stack.root = {};
logger->error() << strerror(errno) << std::endl;
break;
}
if (XML_Parse(parser, buffer, in->gcount(), in->eof()) == XML_STATUS_ERROR) {
stack.root = {};
logger->error(XML_GetCurrentLineNumber(parser))
<< XML_ErrorString(XML_GetErrorCode(parser)) << std::endl;
break;
}
}
XML_ParserFree(parser);
return std::move(stack.root);
}
nad_t nad_parse(const char *buf, int len) {
struct build_data bd;
XML_Parser p;
if(len == 0)
len = strlen(buf);
p = XML_ParserCreateNS(NULL, '|');
if(p == NULL)
return NULL;
XML_SetReturnNSTriplet(p, 1);
bd.nad = nad_new();
bd.depth = 0;
XML_SetUserData(p, (void *) &bd);
XML_SetElementHandler(p, _nad_parse_element_start, _nad_parse_element_end);
XML_SetCharacterDataHandler(p, _nad_parse_cdata);
XML_SetStartNamespaceDeclHandler(p, _nad_parse_namespace_start);
if(!XML_Parse(p, buf, len, 1)) {
XML_ParserFree(p);
nad_free(bd.nad);
return NULL;
}
XML_ParserFree(p);
if(bd.depth != 0)
return NULL;
return bd.nad;
}
static int
framer_initialize(framer_t *framer)
{
framer_cleanup(framer);
framer->parser = XML_ParserCreateNS(NULL, /* ':' */ '\xFF');
if (framer->parser == NULL)
goto Error;
XML_SetElementHandler(
framer->parser,
framer_start,
framer_end);
XML_SetUserData(
framer->parser,
framer);
framer->level = 0;
framer->error = 0;
framer->index = 0;
framer->buffer_index = 0;
framer->head = framer->tail = NULL;
framer->buffer = buffer_create(0);
if (framer->buffer == NULL)
goto Error;
return 1;
Error:
if (framer->parser != NULL)
XML_ParserFree(framer->parser);
return 0;
}
Appcast Appcast::Load(const std::string& xml, const std::string& lang)
{
XML_Parser p = XML_ParserCreateNS(NULL, NS_SEP);
if ( !p )
throw std::runtime_error("Failed to create XML parser.");
ContextData ctxt(p);
XML_SetUserData(p, &ctxt);
XML_SetElementHandler(p, OnStartElement, OnEndElement);
XML_SetCharacterDataHandler(p, OnText);
XML_Status st = XML_Parse(p, xml.c_str(), xml.size(), XML_TRUE);
if ( st == XML_STATUS_ERROR )
{
std::string msg("XML parser error: ");
msg.append(XML_ErrorString(XML_GetErrorCode(p)));
XML_ParserFree(p);
throw std::runtime_error(msg);
}
XML_ParserFree(p);
if (ctxt.items.empty())
return Appcast(); // invalid
/*
* Search for first <item> which specifies with the attribute sparkle:os set to "windows"
* or "windows-x64"/"windows-x86" based on this modules bitness and meets the minimum
* os version, if set. If none, use the first item that meets the minimum os version, if set.
*/
std::vector<Appcast>::iterator it = std::find_if(ctxt.items.begin(), ctxt.items.end(),
[=](const Appcast& item)
{
bool ret = false;
ret = is_suitable_windows_item(item) && is_suitable_language_item(item, lang);
return ret;
});
if (it != ctxt.items.end())
return *it;
else
{
it = std::find_if(ctxt.items.begin(), ctxt.items.end(),
[=](const Appcast& item)
{
bool ret = false;
ret = is_windows_version_acceptable(item) && is_suitable_language_item(item, lang);
return ret;
});
if (it != ctxt.items.end())
return *it;
else
return Appcast(); // There are no items that meet the set minimum os version
}
}
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(void)
{
CURL *curl_handle;
CURLcode res;
XML_Parser parser;
struct ParserStruct state;
/* Initialize the state structure for parsing. */
memset(&state, 0, sizeof(struct ParserStruct));
state.ok = 1;
/* Initialize a namespace-aware parser. */
parser = XML_ParserCreateNS(NULL, '\0');
XML_SetUserData(parser, &state);
XML_SetElementHandler(parser, startElement, endElement);
XML_SetCharacterDataHandler(parser, characterDataHandler);
/* Initialize a libcurl handle. */
curl_global_init(CURL_GLOBAL_ALL ^ CURL_GLOBAL_SSL);
curl_handle = curl_easy_init();
curl_easy_setopt(curl_handle, CURLOPT_URL,
"http://www.w3schools.com/xml/simple.xml");
curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, parseStreamCallback);
curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)parser);
printf("Depth Characters Closing Tag\n");
/* Perform the request and any follow-up parsing. */
res = curl_easy_perform(curl_handle);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
else if(state.ok) {
/* Expat requires one final call to finalize parsing. */
if(XML_Parse(parser, NULL, 0, 1) == 0) {
int error_code = XML_GetErrorCode(parser);
fprintf(stderr, "Finalizing parsing failed with error code %d (%s).\n",
error_code, XML_ErrorString(error_code));
}
else {
printf(" --------------\n");
printf(" %lu tags total\n", state.tags);
}
}
/* Clean up. */
free(state.characters.memory);
XML_ParserFree(parser);
curl_easy_cleanup(curl_handle);
curl_global_cleanup();
return 0;
}
XML_Parser sb_parser_new()
{
XML_Parser p;
BrokerParserData *bp = calloc(1, sizeof(BrokerParserData));
p = XML_ParserCreateNS(NULL, ' ');
XML_SetUserData(p, bp);
XML_SetElementHandler(p, sbx_start, sbx_end);
XML_SetCharacterDataHandler(p, getText);
return p;
}
static int
create_parser(struct exmpp_xml_data *edd)
{
/* Create a parser. */
edd->parser = XML_ParserCreateNS("UTF-8", NS_SEP);
if (edd->parser == NULL)
return (-1);
init_parser(edd);
return (0);
}
END_TEST
/*
* Namespaces tests.
*/
static void
namespace_setup(void)
{
parser = XML_ParserCreateNS(NULL, ' ');
if (parser == NULL)
fail("Parser not created.");
}
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);
}
struct xmpp_parser* xmpp_parser_new(bool is_stream_start) {
struct xmpp_parser *parser = calloc(1, sizeof(*parser));
check_mem(parser);
parser->parser = XML_ParserCreateNS(NULL, XMPP_PARSER_SEPARATOR);
check(parser->parser != NULL, "Error creating XML parser");
init_parser(parser, is_stream_start);
return parser;
error:
free(parser);
return NULL;
}
/**
* Creates a new Expat parser. Called from the Java ExpatParser constructor.
*
* @param object the Java ExpatParser instance
* @param javaEncoding the character encoding name
* @param processNamespaces true if the parser should handle namespaces
* @returns the pointer to the C Expat parser
*/
static jlong ExpatParser_initialize(JNIEnv* env, jobject object, jstring javaEncoding,
jboolean processNamespaces) {
// Allocate parsing context.
UniquePtr<ParsingContext> context(new ParsingContext(object));
if (context.get() == NULL) {
jniThrowOutOfMemoryError(env, NULL);
return 0;
}
context->processNamespaces = processNamespaces;
// Create a parser.
XML_Parser parser;
ScopedUtfChars encoding(env, javaEncoding);
if (encoding.c_str() == NULL) {
return 0;
}
if (processNamespaces) {
// Use '|' to separate URIs from local names.
parser = XML_ParserCreateNS(encoding.c_str(), '|');
} else {
parser = XML_ParserCreate(encoding.c_str());
}
if (parser != NULL) {
if (processNamespaces) {
XML_SetNamespaceDeclHandler(parser, startNamespace, endNamespace);
XML_SetReturnNSTriplet(parser, 1);
}
XML_SetCdataSectionHandler(parser, startCdata, endCdata);
XML_SetCharacterDataHandler(parser, text);
XML_SetCommentHandler(parser, comment);
XML_SetDoctypeDeclHandler(parser, startDtd, endDtd);
XML_SetElementHandler(parser, startElement, endElement);
XML_SetExternalEntityRefHandler(parser, handleExternalEntity);
XML_SetNotationDeclHandler(parser, notationDecl);
XML_SetProcessingInstructionHandler(parser, processingInstruction);
XML_SetUnparsedEntityDeclHandler(parser, unparsedEntityDecl);
XML_SetUserData(parser, context.release());
} else {
jniThrowOutOfMemoryError(env, NULL);
return 0;
}
return fromXMLParser(parser);
}
int QgsGml::getFeatures( const QByteArray &data, QGis::WkbType* wkbType, QgsRectangle* extent )
{
mWkbType = wkbType;
mExtent.setMinimal();
XML_Parser p = XML_ParserCreateNS( NULL, NS_SEPARATOR );
XML_SetUserData( p, this );
XML_SetElementHandler( p, QgsGml::start, QgsGml::end );
XML_SetCharacterDataHandler( p, QgsGml::chars );
int atEnd = 1;
XML_Parse( p, data.constData(), data.size(), atEnd );
if ( extent )
*extent = mExtent;
return 0;
}
sp<XMLNode> XMLNode::parse(const sp<AaptFile>& file)
{
char buf[16384];
int fd = open(file->getSourceFile().string(), O_RDONLY | O_BINARY);
if (fd < 0) {
SourcePos(file->getSourceFile(), -1).error("Unable to open file for read: %s",
strerror(errno));
return NULL;
}
XML_Parser parser = XML_ParserCreateNS(NULL, 1);
ParseState state;
state.filename = file->getPrintableSource();
state.parser = parser;
XML_SetUserData(parser, &state);
XML_SetElementHandler(parser, startElement, endElement);
XML_SetNamespaceDeclHandler(parser, startNamespace, endNamespace);
XML_SetCharacterDataHandler(parser, characterData);
XML_SetCommentHandler(parser, commentData);
ssize_t len;
bool done;
do {
len = read(fd, buf, sizeof(buf));
done = len < (ssize_t)sizeof(buf);
if (len < 0) {
SourcePos(file->getSourceFile(), -1).error("Error reading file: %s\n", strerror(errno));
close(fd);
return NULL;
}
if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) {
SourcePos(file->getSourceFile(), (int)XML_GetCurrentLineNumber(parser)).error(
"Error parsing XML: %s\n", XML_ErrorString(XML_GetErrorCode(parser)));
close(fd);
return NULL;
}
} while (!done);
XML_ParserFree(parser);
if (state.root == NULL) {
SourcePos(file->getSourceFile(), -1).error("No XML data generated when parsing");
}
close(fd);
return state.root;
}
nad_t nad_parse(const char *buf, int len) {
struct build_data bd;
XML_Parser p;
if(len == 0)
len = strlen(buf);
p = XML_ParserCreateNS(NULL, '|');
if(p == NULL)
return NULL;
bd.p = p;
XML_SetReturnNSTriplet(p, 1);
/* Prevent the "billion laughs" attack against expat by disabling
* internal entity expansion. With 2.x, forcibly stop the parser
* if an entity is declared - this is safer and a more obvious
* failure mode. With older versions, simply prevent expenansion
* of such entities. */
#ifdef HAVE_XML_STOPPARSER
XML_SetEntityDeclHandler(p, (void *) _nad_parse_entity_declaration);
#else
XML_SetDefaultHandler(p, NULL);
#endif
bd.nad = nad_new();
bd.depth = 0;
XML_SetUserData(p, (void *) &bd);
XML_SetElementHandler(p, _nad_parse_element_start, _nad_parse_element_end);
XML_SetCharacterDataHandler(p, _nad_parse_cdata);
XML_SetStartNamespaceDeclHandler(p, _nad_parse_namespace_start);
if(!XML_Parse(p, buf, len, 1)) {
XML_ParserFree(p);
nad_free(bd.nad);
return NULL;
}
XML_ParserFree(p);
if(bd.depth != 0)
return NULL;
return bd.nad;
}
static int lxp_make_parser (lua_State *L) {
XML_Parser p;
int bufferCharData = (lua_type(L, 3) != LUA_TBOOLEAN) || (lua_toboolean(L, 3) != 0);
char sep = *luaL_optstring(L, 2, "");
lxp_userdata *xpu = createlxp(L);
xpu->bufferCharData = bufferCharData;
p = xpu->parser = (sep == '\0') ? XML_ParserCreate(NULL) :
XML_ParserCreateNS(NULL, sep);
if (!p)
luaL_error(L, "XML_ParserCreate failed");
luaL_checktype(L, 1, LUA_TTABLE);
checkcallbacks(L);
lua_pushvalue(L, 1);
xpu->tableref = luaL_ref(L, LUA_REGISTRYINDEX);
XML_SetUserData(p, xpu);
if (hasfield(L, StartCdataKey) || hasfield(L, EndCdataKey))
XML_SetCdataSectionHandler(p, f_StartCdata, f_EndCdataKey);
if (hasfield(L, CharDataKey))
XML_SetCharacterDataHandler(p, f_CharData);
if (hasfield(L, CommentKey))
XML_SetCommentHandler(p, f_Comment);
if (hasfield(L, DefaultKey))
XML_SetDefaultHandler(p, f_Default);
if (hasfield(L, DefaultExpandKey))
XML_SetDefaultHandlerExpand(p, f_DefaultExpand);
if (hasfield(L, StartElementKey) || hasfield(L, EndElementKey))
XML_SetElementHandler(p, f_StartElement, f_EndElement);
if (hasfield(L, ExternalEntityKey))
XML_SetExternalEntityRefHandler(p, f_ExternaEntity);
if (hasfield(L, StartNamespaceDeclKey) || hasfield(L, EndNamespaceDeclKey))
XML_SetNamespaceDeclHandler(p, f_StartNamespaceDecl, f_EndNamespaceDecl);
if (hasfield(L, NotationDeclKey))
XML_SetNotationDeclHandler(p, f_NotationDecl);
if (hasfield(L, NotStandaloneKey))
XML_SetNotStandaloneHandler(p, f_NotStandalone);
if (hasfield(L, ProcessingInstructionKey))
XML_SetProcessingInstructionHandler(p, f_ProcessingInstruction);
if (hasfield(L, UnparsedEntityDeclKey))
XML_SetUnparsedEntityDeclHandler(p, f_UnparsedEntityDecl);
if (hasfield(L, StartDoctypeDeclKey))
XML_SetStartDoctypeDeclHandler(p, f_StartDoctypeDecl);
if (hasfield(L, XmlDeclKey))
XML_SetXmlDeclHandler(p, f_XmlDecl);
return 1;
}
int QgsWFSData::getWFSData()
{
XML_Parser p = XML_ParserCreateNS( NULL, NS_SEPARATOR );
XML_SetUserData( p, this );
XML_SetElementHandler( p, QgsWFSData::start, QgsWFSData::end );
XML_SetCharacterDataHandler( p, QgsWFSData::chars );
//separate host from query string
QUrl requestUrl( mUri );
int portNr = requestUrl.port();
if ( portNr != -1 )
{
mHttp.setHost( requestUrl.host(), portNr );
}
else
{
mHttp.setHost( requestUrl.host() );
}
//mHttp.get( mUri );
mHttp.get( requestUrl.path() + "?" + QString( requestUrl.encodedQuery() ) );
//loop to read the data
QByteArray readData;
int atEnd = 0;
qWarning( "Entering loop" );
while ( !mFinished || mHttp.bytesAvailable() > 0 )
{
if ( mFinished )
{
atEnd = 1;
}
if ( mHttp.bytesAvailable() != 0 )
{
readData = mHttp.readAll();
XML_Parse( p, readData.data(), readData.size(), atEnd );
}
qApp->processEvents( QEventLoop::ExcludeUserInputEvents );
}
qWarning( "Left loop" );
return 0; //soon
}
int main(int argc, char **argv) {
AppData *ad;
XML_Parser p = XML_ParserCreateNS(NULL, '|');
if (! p) {
fprintf(stderr, "Couldn't allocate memory for parser\n");
exit(-1);
}
ad = newAppData();
XML_SetUserData(p, (void *) ad);
XML_SetElementHandler(p, start, end);
XML_SetNamespaceDeclHandler(p, ns_start, ns_end);
for (;;) {
char *buff;
int len;
buff = XML_GetBuffer(p, CHUNK_SIZE);
if (! buff) {
fprintf(stderr, "Ran out of memory for parse buffer\n");
exit(-1);
}
len = read(0, buff, CHUNK_SIZE);
if (len < 0) {
perror("namespace - read error");
exit(-1);
}
if (! XML_ParseBuffer(p, len, len == 0)) {
fprintf(stderr, "Parse error at line %lu:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
exit(-1);
}
if (len == 0)
break;
}
return 0;
} /* End main */
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 document_imp::parse(
istream& data)
{
XML_Parser p = XML_ParserCreateNS(NULL, '=');
if (p == NULL)
THROW_EXCEPTION(("failed to create expat parser object"));
try
{
XML_SetUserData(p, this);
XML_SetElementHandler(p, XML_StartElementHandler, XML_EndElementHandler);
XML_SetCharacterDataHandler(p, XML_CharacterDataHandler);
// XML_SetProcessingInstructionHandler(p, XML_ProcessingInstructionHandler);
// XML_SetCommentHandler(p, XML_CommentHandler);
// XML_SetCdataSectionHandler(p, XML_StartCdataSectionHandler, XML_EndCdataSectionHandler);
// XML_SetDefaultHandler(p, XML_DefaultHandler);
// XML_SetDoctypeDeclHandler(p, XML_StartDoctypeDeclHandler, XML_EndDoctypeDeclHandler);
// XML_SetUnparsedEntityDeclHandler(p, XML_UnparsedEntityDeclHandler);
// XML_SetNotationDeclHandler(p, XML_NotationDeclHandler);
XML_SetNamespaceDeclHandler(p, XML_StartNamespaceDeclHandler, XML_EndNamespaceDeclHandler);
XML_SetReturnNSTriplet(p, true);
while (not data.eof())
{
string line;
getline(data, line);
line += '\n';
XML_Status err = XML_Parse(p, line.c_str(), line.length(), data.eof() or line.empty());
if (err != XML_STATUS_OK)
THROW_EXCEPTION((p));
}
}
catch (std::exception& e)
{
XML_ParserFree(p);
throw;
}
XML_ParserFree(p);
}
/* shuts down and restarts XML parser. true on success */
int parser_reset(parser_t *parser)
{
if (parser->expat)
XML_ParserFree(parser->expat);
if (parser->stanza)
xmpp_stanza_release(parser->stanza);
parser->expat = XML_ParserCreateNS(NULL, NAMESPACE_SEP);
if (!parser->expat) return 0;
parser->depth = 0;
parser->stanza = NULL;
XML_SetUserData(parser->expat, parser);
XML_SetElementHandler(parser->expat, _start_element, _end_element);
XML_SetCharacterDataHandler(parser->expat, _characters);
return 1;
}
framer_t *
framer_create()
{
framer_t *framer = (framer_t*) malloc(sizeof(*framer));
if (framer == NULL)
goto Error;
memset(framer, 0, sizeof(*framer));
framer->parser = XML_ParserCreateNS(NULL, /* ':' */ '\xFF');
if (framer->parser == NULL)
goto Error;
XML_SetElementHandler(
framer->parser,
framer_start,
framer_end);
XML_SetUserData(
framer->parser,
framer);
framer->level = 0;
framer->error = 0;
framer->index = 0;
framer->buffer_index = 0;
framer->head = framer->tail = NULL;
/* TODO: create buffers with limited maximum length */
framer->buffer = buffer_create(0);
if (framer->buffer == NULL)
goto Error;
return framer;
Error:
if (framer != NULL)
{
if (framer->buffer != NULL)
buffer_delete(framer->buffer);
if (framer->parser != NULL)
XML_ParserFree(framer->parser);
}
return NULL;
}
static void validate(int start,int fd) {
void *buf; int len;
previous=current=start;
expat=XML_ParserCreateNS(NULL,':');
XML_SetElementHandler(expat,&start_element,&end_element);
XML_SetCharacterDataHandler(expat,&characters);
ok=1; any=0;
for(;;) {
buf=XML_GetBuffer(expat,BUFSIZE);
len=read(fd,buf,BUFSIZE);
if(len<0) {
(*er_printf)("error (%s): %s\n",xml,strerror(errno));
wf=ok=0; break;
}
if(!XML_ParseBuffer(expat,len,len==0)) wf=ok=0;
if(!ok||any||len==0) break;
}
XML_ParserFree(expat);
return;
}
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;
}
void
runexpatNSuD(enum isource from,
void * list,
XML_StartElementHandler startElement,
XML_EndElementHandler endElement,
XML_Char *ns_sep_p,
void *uData)
{
const char *buf;
XML_Parser parser;
static int depth;
struct runinfo *rip = calloc(1,sizeof(struct runinfo));
if (curr_rip)
{
/* This version of runexpat.c doesn't handle nested contexts */
abort();
}
curr_rip = rip;
if (ns_sep_p)
parser = XML_ParserCreateNS("utf-8",*ns_sep_p);
else
parser = XML_ParserCreate("utf-8");
if (!parser)
{
fprintf(stderr,"runexpat: NULL return from XML_ParserCreate()\n");
return;
}
depth = 0;
runexpat_init(rip);
rip->from = from;
rip->list = list;
rip->charData_buflen = 1024;
rip->charData_buf = malloc(sizeof(XML_Char) * rip->charData_buflen);
rip->charData_bufused = 0;
if (uData)
XML_SetUserData(parser, uData);
else
XML_SetUserData(parser, &depth);
XML_SetElementHandler(parser, startElement, endElement);
XML_SetCharacterDataHandler(parser, charHandler);
if (!XML_Parse(parser,"<rp-wrap>",9,0))
fail(parser, rip);
set_input(rip);
for (;;)
{
if (NULL == (buf = get_input(rip)))
break;
if (rip->input_len && !XML_Parse(parser, buf, rip->input_len, 0))
{
fprintf(stderr,"===\n%s\n===\n",buf);
fail(parser, rip);
}
}
if (!XML_Parse(parser,"</rp-wrap>",10,1))
fail(parser, rip);
XML_ParserFree(parser);
runexpat_term(rip);
free(rip->fname);
free(rip);
curr_rip = NULL;
}
if (m_parser) XML_ParserFree(m_parser);
/**
* Constructs a new parser that has namespace processing in effect.
* If encoding is non-null, it specifies a character encoding to use for the document.
* This overrides the document encoding declaration. There are four built-in encodings:
* US-ASCII
* UTF-8
* UTF-16
* ISO-8859-1
* Namespace expanded element names and attribute names are returned as a concatenation of the namespace URI, sep,
* and the local part of the name. This means that you should pick a character for sep that can't be part of a legal URI
*/
m_parser = (ns ? XML_ParserCreateNS(encoding, '#')
: XML_ParserCreate(encoding));
XML_SetUserData( m_parser, this);
XML_SetElementHandler( m_parser, UXMLParser::_startElement,
UXMLParser::_endElement);
XML_SetCharacterDataHandler( m_parser, UXMLParser::_characterData);
if (ns)
{
XML_SetStartNamespaceDeclHandler(m_parser, UXMLParser::_startNamespace);
XML_SetEndNamespaceDeclHandler( m_parser, UXMLParser::_endNamespace);
}
}
// DEBUG
WBXML_DECLARE(WBXMLError) wbxml_tree_from_xml(WB_UTINY *xml, WB_ULONG xml_len, WBXMLTree **tree)
{
#if defined( HAVE_EXPAT )
const XML_Feature *feature_list = NULL;
XML_Parser xml_parser = NULL;
WBXMLError ret = WBXML_OK;
WB_BOOL expat_utf16 = FALSE;
WBXMLTreeClbCtx wbxml_tree_clb_ctx;
/* First Check if Expat is outputing UTF-16 strings */
feature_list = (const XML_Feature *)XML_GetFeatureList();
if ((feature_list != NULL) && (feature_list[0].value != sizeof(WB_TINY))) {
#if !defined( HAVE_ICONV )
/* Ouch, can't convert from UTF-16 to UTF-8 */
return WBXML_ERROR_XMLPARSER_OUTPUT_UTF16;
#else
/* Expat returns UTF-16 encoded strings in its callbacks */
expat_utf16 = TRUE;
#endif /* !HAVE_ICONV */
}
if (tree != NULL)
*tree = NULL;
/* Create Expat XML Parser */
if ((xml_parser = XML_ParserCreateNS(NULL, WBXML_NAMESPACE_SEPARATOR)) == NULL)
return WBXML_ERROR_NOT_ENOUGH_MEMORY;
/* Init context */
wbxml_tree_clb_ctx.current = NULL;
wbxml_tree_clb_ctx.error = WBXML_OK;
wbxml_tree_clb_ctx.skip_lvl = 0;
wbxml_tree_clb_ctx.skip_start = 0;
wbxml_tree_clb_ctx.xml_parser = xml_parser;
wbxml_tree_clb_ctx.input_buff = xml;
wbxml_tree_clb_ctx.expat_utf16 = expat_utf16;
/* Create WBXML Tree */
if ((wbxml_tree_clb_ctx.tree = wbxml_tree_create(WBXML_LANG_UNKNOWN, WBXML_CHARSET_UNKNOWN)) == NULL) {
XML_ParserFree(xml_parser);
WBXML_ERROR((WBXML_PARSER, "Can't create WBXML Tree"));
return WBXML_ERROR_NOT_ENOUGH_MEMORY;
}
/* Set Handlers Callbacks */
XML_SetXmlDeclHandler(xml_parser, wbxml_tree_clb_xml_decl);
XML_SetStartDoctypeDeclHandler(xml_parser, wbxml_tree_clb_xml_doctype_decl);
XML_SetElementHandler(xml_parser, wbxml_tree_clb_xml_start_element, wbxml_tree_clb_xml_end_element);
XML_SetCdataSectionHandler(xml_parser, wbxml_tree_clb_xml_start_cdata, wbxml_tree_clb_xml_end_cdata);
XML_SetProcessingInstructionHandler(xml_parser , wbxml_tree_clb_xml_pi);
XML_SetCharacterDataHandler(xml_parser, wbxml_tree_clb_xml_characters);
XML_SetUserData(xml_parser, (void*)&wbxml_tree_clb_ctx);
/* Parse the XML Document to WBXML Tree */
if (XML_Parse(xml_parser, (WB_TINY*) xml, xml_len, TRUE) == 0)
{
WBXML_ERROR((WBXML_CONV, "xml2wbxml conversion failed - expat error %i\n"
"\tdescription: %s\n"
"\tline: %i\n"
"\tcolumn: %i\n"
"\tbyte index: %i\n"
"\ttotal bytes: %i\n%s",
XML_GetErrorCode(xml_parser),
XML_ErrorString(XML_GetErrorCode(xml_parser)),
XML_GetCurrentLineNumber(xml_parser),
XML_GetCurrentColumnNumber(xml_parser),
XML_GetCurrentByteIndex(xml_parser),
XML_GetCurrentByteCount(xml_parser), xml));
wbxml_tree_destroy(wbxml_tree_clb_ctx.tree);
ret = WBXML_ERROR_XML_PARSING_FAILED;
}
else {
if ((ret = wbxml_tree_clb_ctx.error) != WBXML_OK)
{
WBXML_ERROR((WBXML_CONV, "xml2wbxml conversion failed - context error %i", ret));
wbxml_tree_destroy(wbxml_tree_clb_ctx.tree);
}
else
*tree = wbxml_tree_clb_ctx.tree;
}
/* Clean-up */
XML_ParserFree(xml_parser);
return ret;
#else /* HAVE_EXPAT */
#if defined( HAVE_LIBXML )
/** @todo Use LibXML2 SAX interface ! */
return WBXML_ERROR_NO_XMLPARSER;
#else /* HAVE_LIBXML */
/** @note You can add here another XML Parser support */
return WBXML_ERROR_NO_XMLPARSER;
#endif /* HAVE_LIBXML */
#endif /* HAVE_EXPAT */
}
