static VALUE
parse_doc(VALUE ctxt_val)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctxt_val;
xmlParseDocument(ctxt);
return Qnil;
}
// A modified version of XmlSAXParseFile in gnome-xml. This one lets us set
// the user_data that is passed to the various callbacks, to make it possible
// to avoid lots of global variables.
gboolean oreganoXmlSAXParseFile (xmlSAXHandlerPtr sax, gpointer user_data, const gchar *filename)
{
g_return_val_if_fail (filename != NULL, FALSE);
gboolean parser_failed, ret = TRUE;
xmlParserCtxtPtr ctxt;
ctxt = xmlCreateFileParserCtxt (filename);
if (ctxt == NULL)
return FALSE;
ctxt->sax = sax;
ctxt->userData = user_data;
#if defined(LIBXML_VERSION) && LIBXML_VERSION >= 20000
xmlKeepBlanksDefault (0);
#endif
parser_failed = FALSE;
if (xmlParseDocument (ctxt) < 0) {
// FIXME post a message to the log buffer with as much details as possible
g_message ("Failed to parse \"%s\"", filename);
ret = FALSE;
parser_failed = TRUE;
} else {
ret = ctxt->wellFormed ? TRUE : FALSE;
if (sax != NULL)
ctxt->sax = NULL;
}
if (!parser_failed)
xmlFreeParserCtxt (ctxt);
return ret;
}
int main(int argc, char **argv) {
xmlParserCtxtPtr ctxt;
xmlsatParseState state;
if (argc<2) {
printf("Usage: %s [-fta] filename.xmlsat\n",argv[0]);
} else {
if (argc==2) {
ctxt = (xmlParserCtxtPtr)xmlCreateFileParserCtxt(argv[1]);
} else if (argc==3) {
if (strcmp(argv[1],"-fta")==0) {
fta=1;
}
ctxt = (xmlParserCtxtPtr)xmlCreateFileParserCtxt(argv[2]);
}
if (ctxt == NULL) {
fprintf(stderr,"ERROR: can not open file\n");
}
ctxt->sax = &xmlsatSAXParser;
ctxt->userData = &state;
xmlParseDocument(ctxt);
ctxt->sax = NULL;
xmlFreeParserCtxt(ctxt);
}
return 0;
}
bool XParser::ParseContext(xmlParserCtxtPtr pxParseCtxt)
{
/** initialize context begin **/
pxParseCtxt->linenumbers = 1;
//有效性检查
//pxParseCtxt->validate = (validate_ ? 1 : 0);
//初始化error和varning的回调函数
//pxParseCtxt->vctxt.error = &callback_validity_error;
//pxParseCtxt->vctxt.warning = &callback_validity_warning;
//允许callback_validity_*回调函数回去C++指针
pxParseCtxt->_private = this;
//pxParseCtxt->replaceEntities = (substitute_entities_ ? 1 : 0);
/** initialize context end **/
xmlParseDocument(pxParseCtxt);
if(!pxParseCtxt->wellFormed)
{
return false;
}
if(pxParseCtxt->errNo != 0)
{
return false;
}
return true;
}
gboolean
ide_xml_sax_parse (IdeXmlSax *self,
const gchar *data,
gsize length,
const gchar *uri,
gpointer user_data)
{
gboolean wellformed;
g_return_val_if_fail (IDE_IS_XML_SAX (self), FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (length > 0, FALSE);
g_return_val_if_fail (self->initialized == TRUE, FALSE);
g_return_val_if_fail (self->context == NULL, FALSE);
self->context = xmlCreateMemoryParserCtxt (data, length);
self->context->userData = user_data;
self->context->sax = &self->handler;
self->handler.initialized = XML_SAX2_MAGIC;
xmlCtxtUseOptions (self->context, XML_PARSE_RECOVER | XML_PARSE_NOENT);
xmlParseDocument (self->context);
wellformed = self->context->wellFormed;
self->context->sax = NULL;
g_clear_pointer (&self->context, xmlFreeParserCtxt);
return wellformed;
}
/*
* call-seq:
* parser.parse -> (true|false)
*
* Parse the input XML, generating callbacks to the object
* registered via the +callbacks+ attributesibute.
*/
static VALUE rxml_sax_parser_parse(VALUE self)
{
int status;
VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
xmlParserCtxtPtr ctxt;
Data_Get_Struct(context, xmlParserCtxt, ctxt);
ctxt->sax2 = 1;
ctxt->userData = (void*)rb_ivar_get(self, CALLBACKS_ATTR);
if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
xmlFree(ctxt->sax);
ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(rxml_sax_handler));
if (ctxt->sax == NULL)
rb_fatal("Not enough memory.");
memcpy(ctxt->sax, &rxml_sax_handler, sizeof(rxml_sax_handler));
status = xmlParseDocument(ctxt);
/* Now check the parsing result*/
if (status == -1 || !ctxt->wellFormed)
{
if (ctxt->myDoc)
xmlFreeDoc(ctxt->myDoc);
rxml_raise(&ctxt->lastError);
}
return Qtrue;
}
/*
* call-seq:
* parse_with(sax_handler)
*
* Use +sax_handler+ and parse the current document
*/
static VALUE parse_with(VALUE self, VALUE sax_handler)
{
if(!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser))
rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
xmlParserCtxtPtr ctxt;
Data_Get_Struct(self, xmlParserCtxt, ctxt);
xmlSAXHandlerPtr sax;
Data_Get_Struct(sax_handler, xmlSAXHandler, sax);
// Free the sax handler since we'll assign our own
if(ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler)
xmlFree(ctxt->sax);
ctxt->sax = sax;
ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
xmlParseDocument(ctxt);
if(NULL != ctxt->myDoc) xmlFreeDoc(ctxt->myDoc);
NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
return Qnil ;
}
/* Taken from libxml2, xmlSAXParseMemoryWithData */
xmlDocPtr mxslt_doc_xml_load_entity(mxslt_doc_t * document, char * localfile) {
xmlParserCtxtPtr ctx;
xmlParserInputPtr input;
xmlDocPtr retval;
xmlChar * filename;
mxslt_doc_debug_print(document, MXSLT_DBG_LIBXML | MXSLT_DBG_DEBUG | MXSLT_DBG_VERBOSE0,
"load_entity/xmlCreateMemoryParserCtxt -- replacing entities: %08x\n", xmlSubstituteEntitiesDefaultValue);
/* SNIPPET: This is a good mix&shake of
* xmlCreateMemoryParserCtxt, xmlCreateFileParserCtxt */
ctx=xmlNewParserCtxt();
if(ctx == NULL)
return NULL;
#if LIBXML_VERSION >= 20600
xmlCtxtUseOptions(ctx, MXSLT_XSLT_OPTIONS);
#endif
/* Remember which document we are parsing
* in this context */
/* ctx->_private=document; */
filename=xmlCanonicPath((xmlChar *)localfile);
if(filename == NULL) {
xmlFreeParserCtxt(ctx);
return NULL;
}
input=xmlLoadExternalEntity((char *)filename, NULL, ctx);
xmlFree(filename);
if(input == NULL) {
xmlFreeParserCtxt(ctx);
return NULL;
}
inputPush(ctx, input);
if(ctx->directory == NULL)
ctx->directory=xmlParserGetDirectory(localfile);
/* END SNIPPET */
/* MXSLT_DUMP_CTX(ctx); */
/* Parse document */
xmlParseDocument(ctx);
if(ctx->wellFormed)
retval=ctx->myDoc;
else {
retval=NULL;
xmlFreeDoc(ctx->myDoc);
ctx->myDoc=NULL;
}
xmlFreeParserCtxt(ctx);
return retval;
}
static int
rxml_sax_parser_parse_io(VALUE self, VALUE input) {
VALUE io = rb_ivar_get(input, IO_ATTR);
VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
xmlCharEncoding xmlEncoding = NUM2INT(encoding);
xmlParserCtxtPtr ctxt = xmlCreateIOParserCtxt((xmlSAXHandlerPtr)&rxml_sax_hander_struct, (void *)self,
(xmlInputReadCallback) rxml_read_callback,
NULL, (void *)io, xmlEncoding);
return xmlParseDocument(ctxt);
}
xmlDocPtr soap_xmlParseFile(const char *filename)
{
xmlParserCtxtPtr ctxt = NULL;
xmlDocPtr ret;
zend_bool old_allow_url_fopen;
/*
xmlInitParser();
*/
old_allow_url_fopen = PG(allow_url_fopen);
PG(allow_url_fopen) = 1;
ctxt = xmlCreateFileParserCtxt(filename);
PG(allow_url_fopen) = old_allow_url_fopen;
if (ctxt) {
zend_bool old;
ctxt->keepBlanks = 0;
ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
ctxt->sax->comment = soap_Comment;
ctxt->sax->warning = NULL;
ctxt->sax->error = NULL;
/*ctxt->sax->fatalError = NULL;*/
#if LIBXML_VERSION >= 20703
ctxt->options |= XML_PARSE_HUGE;
#endif
old = php_libxml_disable_entity_loader(1);
xmlParseDocument(ctxt);
php_libxml_disable_entity_loader(old);
if (ctxt->wellFormed) {
ret = ctxt->myDoc;
if (ret->URL == NULL && ctxt->directory != NULL) {
ret->URL = xmlCharStrdup(ctxt->directory);
}
} else {
ret = NULL;
xmlFreeDoc(ctxt->myDoc);
ctxt->myDoc = NULL;
}
xmlFreeParserCtxt(ctxt);
} else {
ret = NULL;
}
/*
xmlCleanupParser();
*/
if (ret) {
cleanup_xml_node((xmlNodePtr)ret);
}
return ret;
}
int
RS_XML(libXMLEventParse)(const char *fileName, RS_XMLParserData *parserData, RS_XML_ContentSourceType asText,
int saxVersion)
{
xmlSAXHandlerPtr xmlParserHandler;
xmlParserCtxtPtr ctx;
int status;
switch(asText) {
case RS_XML_TEXT:
ctx = xmlCreateDocParserCtxt(CHAR_TO_XMLCHAR(fileName));
break;
case RS_XML_FILENAME:
ctx = xmlCreateFileParserCtxt(fileName);
break;
case RS_XML_CONNECTION:
ctx = RS_XML_xmlCreateConnectionParserCtxt((USER_OBJECT_) fileName);
break;
default:
ctx = NULL;
}
if(ctx == NULL) {
PROBLEM "Can't parse %s", fileName
ERROR;
}
xmlParserHandler = (xmlSAXHandlerPtr) S_alloc(sizeof(xmlSAXHandler), 1);
/* Make certain this is initialized so that we don't have any references to unwanted routines! */
memset(xmlParserHandler, '\0', sizeof(xmlSAXHandler));
RS_XML(initXMLParserHandler)(xmlParserHandler, saxVersion);
parserData->ctx = ctx;
ctx->userData = parserData;
ctx->sax = xmlParserHandler;
status = xmlParseDocument(ctx);
ctx->sax = NULL;
xmlFreeParserCtxt(ctx);
return(status);
/* Free(xmlParserHandler); */
}
/*
* Read xmlDocument from server
*/
static xmlDoc *
js_document_read (xmlParserCtxtPtr ctxt, js_session_t *jsp,
const char *url, const char *encoding, int options)
{
xmlParserInputBufferPtr input;
xmlParserInputPtr stream;
xmlDoc *docp;
if (jsp == NULL || ctxt == NULL || jsp->js_state == JSS_DEAD)
return NULL;
xmlCtxtReset(ctxt);
input = js_buffer_create(jsp, XML_CHAR_ENCODING_NONE);
if (input == NULL)
return NULL;
input->closecallback = NULL;
stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
if (stream == NULL) {
xmlFreeParserInputBuffer(input);
return NULL;
}
inputPush(ctxt, stream);
xmlCtxtUseOptions(ctxt, options);
xmlCharEncodingHandlerPtr hdlr;
if (encoding && ((hdlr = xmlFindCharEncodingHandler(encoding)) != NULL))
xmlSwitchToEncoding(ctxt, hdlr);
if (url != NULL && ctxt->input != NULL && ctxt->input->filename == NULL)
ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) url);
/*
* All right. The stage is set, time to open the curtain and let
* the show begin.
*/
xmlParseDocument(ctxt);
docp = ctxt->myDoc;
ctxt->myDoc = NULL;
if (docp && !ctxt->wellFormed) {
xmlFreeDoc(docp);
docp = NULL;
}
return docp;
}
UT_Error UT_XML::parse (const char * buffer, UT_uint32 length)
{
if (!m_bSniffing)
{
UT_ASSERT (m_pListener || m_pExpertListener);
if ((m_pListener == 0) && (m_pExpertListener == 0)) return UT_ERROR;
}
UT_ASSERT (buffer);
if (buffer == 0 || length == 0) return UT_ERROR;
if (!reset_all ()) return UT_OUTOFMEM;
UT_Error ret = UT_OK;
xmlParserCtxtPtr ctxt;
xmlSAXHandler hdl;
memset(&hdl, 0, sizeof(hdl));
hdl.getEntity = _getEntity;
hdl.startElement = _startElement;
hdl.endElement = _endElement;
hdl.characters = _charData;
hdl.error = _errorSAXFunc;
hdl.fatalError = _fatalErrorSAXFunc;
hdl.processingInstruction = _processingInstruction;
hdl.comment = _comment;
hdl.cdataBlock = _cdata;
ctxt = xmlCreateMemoryParserCtxt (buffer, static_cast<int>(length));
if (ctxt == NULL)
{
UT_DEBUGMSG (("Unable to create libxml2 memory context!\n"));
return UT_ERROR;
}
memcpy(ctxt->sax, &hdl, sizeof(hdl));
ctxt->userData = static_cast<void *>(this);
m_bStopped = false;
xmlParseDocument (ctxt);
if (!ctxt->wellFormed) ret = UT_IE_IMPORTERROR;
xmlDocPtr myXmlDoc = ctxt->myDoc;
xmlFreeParserCtxt (ctxt);
xmlFreeDoc(myXmlDoc);
return ret;
}
xmlDocPtr soap_xmlParseMemory(const void *buf, size_t buf_size)
{
xmlParserCtxtPtr ctxt = NULL;
xmlDocPtr ret;
/*
xmlInitParser();
*/
ctxt = xmlCreateMemoryParserCtxt(buf, buf_size);
if (ctxt) {
zend_bool old;
ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
ctxt->sax->comment = soap_Comment;
ctxt->sax->warning = NULL;
ctxt->sax->error = NULL;
/*ctxt->sax->fatalError = NULL;*/
#if LIBXML_VERSION >= 20703
ctxt->options |= XML_PARSE_HUGE;
#endif
old = php_libxml_disable_entity_loader(1);
xmlParseDocument(ctxt);
php_libxml_disable_entity_loader(old);
if (ctxt->wellFormed) {
ret = ctxt->myDoc;
if (ret->URL == NULL && ctxt->directory != NULL) {
ret->URL = xmlCharStrdup(ctxt->directory);
}
} else {
ret = NULL;
xmlFreeDoc(ctxt->myDoc);
ctxt->myDoc = NULL;
}
xmlFreeParserCtxt(ctxt);
} else {
ret = NULL;
}
/*
xmlCleanupParser();
*/
/*
if (ret) {
cleanup_xml_node((xmlNodePtr)ret);
}
*/
return ret;
}
static int ncXmlSAXParseFile(xmlSAXHandlerPtr sax, void *user_data, const char *filename)
{
int ret = 0;
xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(filename);
if (!ctxt)
return -1;
ctxt->sax = sax;
ctxt->userData = user_data;
xmlParseDocument(ctxt);
ret = ctxt->wellFormed ? 0 : -1;
if (sax)
ctxt->sax = NULL;
xmlFreeParserCtxt(ctxt);
return ret;
}
bool LibxmlSaxParser::parseBuffer( const char* uri, const char* buffer, int length )
{
mParserContext = xmlCreateMemoryParserCtxt( buffer, length );
if ( !mParserContext )
{
ParserError error(ParserError::SEVERITY_CRITICAL,
ParserError::ERROR_COULD_NOT_OPEN_FILE,
0,
0,
0,
0,
uri);
IErrorHandler* errorHandler = getParser()->getErrorHandler();
if ( errorHandler )
{
errorHandler->handleError(error);
}
return false;
}
// We let libxml replace the entities
mParserContext->replaceEntities = 1;
if (mParserContext->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
{
xmlFree(mParserContext->sax);
}
mParserContext->sax = &SAXHANDLER;
mParserContext->userData = (void*)this;
initializeParserContext();
xmlParseDocument(mParserContext);
mParserContext->sax = 0;
if ( mParserContext->myDoc )
{
xmlFreeDoc(mParserContext->myDoc);
mParserContext->myDoc = 0;
}
xmlFreeParserCtxt(mParserContext);
mParserContext = 0;
return true;
}
/*
* call-seq:
* parser.parse -> XML::Document
*
* Parse the input XML and create an XML::Document with
* it's content. If an error occurs, XML::Parser::ParseError
* is thrown.
*/
static VALUE rxml_parser_parse(VALUE self)
{
xmlParserCtxtPtr ctxt;
VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
Data_Get_Struct(context, xmlParserCtxt, ctxt);
if ((xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) && ! ctxt->recovery)
{
if (ctxt->myDoc)
xmlFreeDoc(ctxt->myDoc);
rxml_raise(&ctxt->lastError);
}
return rxml_document_wrap(ctxt->myDoc);
}
HarvestResult processHarvestFromFd(int fd, HarvestProcessor* harvestProcessor,
bool shouldProcessData) {
MwsHarvest_SaxUserData user_data;
xmlSAXHandler saxHandler;
xmlParserCtxtPtr ctxtPtr;
HarvestResult result;
result.status = -1;
user_data.harvestProcessor = harvestProcessor;
user_data.shouldProcessData = shouldProcessData;
memset(&saxHandler, 0, sizeof(xmlSAXHandler));
// Registering Sax callbacks
saxHandler.endDocument = my_endDocument;
saxHandler.startElement = my_startElement;
saxHandler.endElement = my_endElement;
saxHandler.characters = my_characters;
saxHandler.warning = my_warning;
saxHandler.error = my_error;
saxHandler.fatalError = my_fatalError;
// Locking libXML -- to allow multi-threaded use
xmlLockLibrary();
// Creating the IOParser context
if ((ctxtPtr = xmlCreateIOParserCtxt(&saxHandler, &user_data,
fdXmlInputReadCallback, nullptr, &fd,
XML_CHAR_ENCODING_UTF8)) ==
nullptr) {
PRINT_WARN("Error while creating the ParserContext\n");
}
// Parsing the document
else if ((result.status = xmlParseDocument(ctxtPtr)) == -1) {
PRINT_WARN("Parsing XML document failed\n");
}
// Freeing the parser context
if (ctxtPtr) {
xmlFreeParserCtxt(ctxtPtr);
}
// Unlocking libXML -- to allow multi-threaded use
xmlUnlockLibrary();
result.numExpressions = user_data.parsedExpr;
return result;
}
TEG_STATUS metaserver_get_servers( void )
{
int s = -1;
int ret;
xmlParserCtxtPtr ctxt;
xmlDocPtr doc = NULL;
metaserver_flush_list();
s = net_connect_tcp("teg.game-server.cc",2002);
if( s < 0 )
goto error;
if( net_printf( s, "GET /listServers_xml HTTP/1.1\r\n\r\n") < 0 )
goto error;
ctxt = xmlCreateIOParserCtxt(NULL, NULL,
(xmlInputReadCallback) net_read,
(xmlInputCloseCallback) net_close,
(void *)s, XML_CHAR_ENCODING_NONE);
xmlParseDocument(ctxt);
ret = ctxt->wellFormed;
doc = ctxt->myDoc;
xmlFreeParserCtxt(ctxt);
if (!ret)
goto error;
if( metaserver_parse_xml( doc ) != TEG_STATUS_SUCCESS )
goto error;
return TEG_STATUS_SUCCESS;
error:
if( doc )
xmlFreeDoc(doc);
if( s >= 0 )
net_close( s );
return TEG_STATUS_ERROR;
}
xmlDocPtr soap_xmlParseMemory(const void *buf, size_t buf_size,
bool skip_clean /*= true */) {
xmlParserCtxtPtr ctxt = nullptr;
xmlDocPtr ret;
/*
xmlInitParser();
*/
ctxt = xmlCreateMemoryParserCtxt((const char *)buf, buf_size);
if (ctxt) {
ctxt->keepBlanks = 0;
ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
ctxt->sax->comment = soap_Comment;
ctxt->sax->warning = nullptr;
ctxt->sax->error = nullptr;
/*ctxt->sax->fatalError = nullptr;*/
auto old = HHVM_FN(libxml_disable_entity_loader)(true);
xmlParseDocument(ctxt);
HHVM_FN(libxml_disable_entity_loader)(old);
if (ctxt->wellFormed) {
ret = ctxt->myDoc;
if (ret->URL == nullptr && ctxt->directory != nullptr) {
ret->URL = xmlCharStrdup(ctxt->directory);
}
} else {
ret = nullptr;
xmlFreeDoc(ctxt->myDoc);
ctxt->myDoc = nullptr;
}
xmlFreeParserCtxt(ctxt);
} else {
ret = nullptr;
}
/*
xmlCleanupParser();
*/
if (!skip_clean && ret) {
cleanup_xml_node((xmlNodePtr)ret);
}
return ret;
}
xmlDocPtr soap_xmlParseMemory(const void *buf, size_t buf_size) {
xmlParserCtxtPtr ctxt = NULL;
xmlDocPtr ret;
/*
xmlInitParser();
*/
ctxt = xmlCreateMemoryParserCtxt((const char *)buf, buf_size);
if (ctxt) {
ctxt->keepBlanks = 0;
ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
ctxt->sax->comment = soap_Comment;
ctxt->sax->warning = NULL;
ctxt->sax->error = NULL;
/*ctxt->sax->fatalError = NULL;*/
xmlParseDocument(ctxt);
if (ctxt->wellFormed) {
ret = ctxt->myDoc;
if (ret->URL == NULL && ctxt->directory != NULL) {
ret->URL = xmlCharStrdup(ctxt->directory);
}
} else {
ret = NULL;
xmlFreeDoc(ctxt->myDoc);
ctxt->myDoc = NULL;
}
xmlFreeParserCtxt(ctxt);
} else {
ret = NULL;
}
/*
xmlCleanupParser();
*/
/*
if (ret) {
cleanup_xml_node((xmlNodePtr)ret);
}
*/
return ret;
}
bool LibxmlSaxParser::parseFile( const char* fileName )
{
mParserContext = xmlCreateFileParserCtxt(fileName);
if ( !mParserContext )
{
ParserError error(ParserError::SEVERITY_CRITICAL,
ParserError::ERROR_COULD_NOT_OPEN_FILE,
0,
0,
0,
0,
fileName);
getParser()->getErrorHandler()->handleError(error);
return false;
}
if (mParserContext->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
{
xmlFree(mParserContext->sax);
}
mParserContext->sax = &SAXHANDLER;
mParserContext->userData = (void*)this;
initializeParserContext();
xmlParseDocument(mParserContext);
mParserContext->sax = 0;
if ( mParserContext->myDoc )
{
xmlFreeDoc(mParserContext->myDoc);
mParserContext->myDoc = 0;
}
xmlFreeParserCtxt(mParserContext);
mParserContext = 0;
return true;
}
bool HandlerBase::Parse( const iStringT& fname )
{
// FName converted to the ascii
CvtTA<> fnameAnsi( fname.CStr() );
context_ = xmlCreateFileParserCtxt( fnameAnsi );
if ( !context_ ) throw SaxError();
xmlSAXHandler sh =
{
0,0,0,0,0,
0, //zGetEntity,
0,0,0,0,0,0,
zStartDocument,
zEndDocument,
zStartElement,
zEndElement,
0,
zCharacters,
0,0,
zComment,
zWarning,
zzError,
zFatalError,
0,
zCDATABlock,
0
};
context_->sax = &sh;
context_->userData = this;
xmlSubstituteEntitiesDefault( 1 );
xmlKeepBlanksDefault( 0 );
xmlParseDocument( context_ );
bool wellFormed = context_->wellFormed ? true : false;
context_->sax = 0;
xmlFreeParserCtxt( context_ );
return wellFormed;
}
xmlDocPtr soap_xmlParseFile(const char *filename) {
const char *url = strstr(filename, "://");
if (url) {
xmlDocPtr ret;
xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(filename);
if (ctxt) {
ctxt->keepBlanks = 0;
ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace;
ctxt->sax->comment = soap_Comment;
ctxt->sax->warning = NULL;
ctxt->sax->error = NULL;
/*ctxt->sax->fatalError = NULL;*/
xmlParseDocument(ctxt);
if (ctxt->wellFormed) {
ret = ctxt->myDoc;
if (ret->URL == NULL && ctxt->directory != NULL) {
ret->URL = xmlCharStrdup(ctxt->directory);
}
} else {
ret = NULL;
xmlFreeDoc(ctxt->myDoc);
ctxt->myDoc = NULL;
}
xmlFreeParserCtxt(ctxt);
} else {
ret = NULL;
}
if (ret) {
cleanup_xml_node((xmlNodePtr)ret);
}
return ret;
}
Variant content = f_file_get_contents(filename);
if (!same(content, false)) {
String scontent = content.toString();
return soap_xmlParseMemory(scontent.data(), scontent.size());
}
return NULL;
}
int main(int argc, char* argv[]) {
xmlParserCtxtPtr ctxt=NULL;
xmlsubsParseState state;
int i;
state.fontfilename=NULL;
state.use_freetype=0;
fprintf(stderr,"argc=%d\n",argc);
i=1;
while (i < argc) {
if (strcmp(argv[i],"-freetype")==0) {
state.use_freetype=1;
} else if (strcmp(argv[i],"-font")==0) {
i++;
state.fontfilename=argv[i];
} else {
if (ctxt==NULL) {
ctxt = (xmlParserCtxtPtr)xmlCreateFileParserCtxt(argv[i]);
}
}
i++;
}
if (ctxt == NULL) {
fprintf(stderr,"Usage: %s [-freetype] [-font font.ttf] filename.xml\n",argv[0]);
exit(1);
}
ctxt->sax = &xmlsubsSAXParser;
ctxt->userData = &state;
xmlParseDocument(ctxt);
ctxt->sax = NULL;
xmlFreeParserCtxt(ctxt);
fprintf(stderr,"Finished!\n");
exit(0);
}
static gboolean
xml_read_context (xmlParserCtxt *ctxt,
MrpProject *project,
GError **error)
{
xmlDoc *doc;
gboolean ret_val;
xmlParseDocument (ctxt);
doc = ctxt->myDoc;
if (!doc) {
g_warning ("Could not read XML.");
return FALSE;
}
if (!ctxt->wellFormed) {
g_warning ("Document not well formed.");
xmlFreeDoc (doc);
return FALSE;
}
switch (xml_locate_type (doc)) {
case XML_TYPE_MRP_1:
g_print ("Isn't implemented yet\n");
ret_val = FALSE;
break;
case XML_TYPE_MRP_0_6:
case XML_TYPE_MRP_0_5_1:
ret_val = mrp_old_xml_parse (project, doc, error);
break;
default:
ret_val = FALSE;
break;
};
xmlFreeDoc (doc);
return ret_val;
}
// implementation of this function is inspired by the SAX documentation by James Henstridge.
// (http://www.daa.com.au/~james/gnome/xml-sax/implementing.html)
void SaxParser::parse()
{
//TODO If this is not the first parsing with this SaxParser, the xmlDoc object
// in entity_resolver_doc_ should be deleted and replaced by a new one.
// Otherwise entity declarations from a previous parsing may erroneously affect
// this parsing. This would be much easier if entity_resolver_doc_ were a
// std::auto_ptr<Document>, so the xmlpp::Document could be deleted and a new
// one created. A good place for such code would be in an overridden
// SaxParser::initialize_context(). It would be an ABI break.
if(!context_)
{
throw internal_error("Parser context not created.");
}
xmlSAXHandlerPtr old_sax = context_->sax;
context_->sax = sax_handler_.get();
xmlResetLastError();
initialize_context();
const int parseError = xmlParseDocument(context_);
context_->sax = old_sax;
Glib::ustring error_str = format_xml_parser_error(context_);
if (error_str.empty() && parseError == -1)
error_str = "xmlParseDocument() failed.";
release_underlying(); // Free context_
check_for_exception();
if(!error_str.empty())
{
throw parse_error(error_str);
}
}
bool HandlerBase::Parse( const char* buf, int size)
{
context_ = xmlCreateMemoryParserCtxt( buf, size );
if ( !context_ ) throw SaxError();
xmlSAXHandler sh =
{
0,0,0,0,0,
0, //zGetEntity,
0,0,0,0,0,0,
zStartDocument,
zEndDocument,
zStartElement,
zEndElement,
0,
zCharacters,
0,0,
zComment,
zWarning,
zzError,
zFatalError,
0,
zCDATABlock,
0
};
context_->sax = &sh;
context_->userData = this;
xmlSubstituteEntitiesDefault( 1 );
xmlKeepBlanksDefault( 0 );
xmlParseDocument( context_ );
bool wellFormed = context_->wellFormed ? true : false;
context_->sax = 0;
xmlFreeParserCtxt( context_ );
return wellFormed;
}
int main() {
int fd;
xmlParserCtxtPtr ctxt;
xmlSAXHandler sax = { 0 };
// Affectation des fonctions de rappels
sax.startElement = debut_element;
// Ouverture du flux
if ((fd = open("catalogue.xml", O_RDONLY)) == -1) {
fprintf(stderr, "Echec sur open\n");
return EXIT_FAILURE;
}
// Création du contexte
if ((ctxt = xmlCreateIOParserCtxt(&sax, NULL, sax_read, sax_close, &fd, XML_CHAR_ENCODING_NONE)) == NULL) {
fprintf(stderr, "Erreur lors de la création du contexte\n");
return EXIT_FAILURE;
}
// Parsing du document
xmlParseDocument(ctxt);
// Libération de la mémoire
xmlFreeParserCtxt(ctxt);
return EXIT_SUCCESS;
}
MwsQuery* readMwsQueryFromFd(int fd)
{
MwsQuery_SaxUserData user_data;
xmlSAXHandler saxHandler;
xmlParserCtxtPtr ctxtPtr;
int ret;
// Initializing the SAX Handler
memset(&saxHandler, 0, sizeof(xmlSAXHandler));
// Registering Sax callbacks with defined ones
//internalSubsetSAXFunc internalSubset;
//isStandaloneSAXFunc isStandalone;
//hasInternalSubsetSAXFunc hasInternalSubset;
//hasExternalSubsetSAXFunc hasExternalSubset;
//resolveEntitySAXFunc resolveEntity;
saxHandler.getEntity = my_getEntity; // STUB
//entityDeclSAXFunc entityDecl;
//notationDeclSAXFunc notationDecl;
//attributeDeclSAXFunc attributeDecl;
//elementDeclSAXFunc elementDecl;
//unparsedEntityDeclSAXFunc unparsedEntityDecl;
//setDocumentLocatorSAXFunc setDocumentLocator;
saxHandler.startDocument = my_startDocument;
saxHandler.endDocument = my_endDocument;
saxHandler.startElement = my_startElement;
saxHandler.endElement = my_endElement;
//referenceSAXFunc reference;
saxHandler.characters = my_characters;
//ignorableWhitespaceSAXFunc ignorableWhitespace;
//processingInstructionSAXFunc processingInstruction;
//commentSAXFunc comment;
saxHandler.warning = my_warning;
saxHandler.error = my_error;
saxHandler.fatalError = my_fatalError;
// Locking libXML -- to allow multi-threaded use
xmlLockLibrary();
// Creating the IOParser context
ctxtPtr = xmlCreateIOParserCtxt(&saxHandler,
&user_data,
fdXmlInputReadCallback,
NULL,
&fd,
XML_CHAR_ENCODING_UTF8);
if (ctxtPtr == NULL)
{
fprintf(stderr, "Error while creating the ParserContext\n");
xmlUnlockLibrary();
return NULL;
}
ret = xmlParseDocument(ctxtPtr);
if (ret == -1)
{
fprintf(stderr, "Parsing failed\n");
}
if (!ctxtPtr->wellFormed)
{
fprintf(stderr, "Bad XML document\n");
}
// Freeing the parser context
xmlFreeParserCtxt(ctxtPtr);
// Unlocking libXML -- to allow multi-threaded use
xmlUnlockLibrary();
return user_data.result;
}
