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; }
void xmlg_parser_error_abort( xmlGParser *xml_parser, HqBool fire_error_handler, uint8 *detail, int32 detail_len) { xmlGParserCommon *c ; xmlGFilterChain *filter_chain ; uint32 line, column ; XMLGASSERT(xml_parser != NULL, "xml_parser is NULL") ; c = xmlg_get_parser_common(xml_parser); XMLGASSERT(c != NULL, "common is NULL"); filter_chain = c->filter_chain ; /* setting the callback functions to NULL ensures we stop */ XML_SetElementHandler(xml_parser->ctxt, NULL, NULL) ; XML_SetStartNamespaceDeclHandler(xml_parser->ctxt, NULL) ; XML_SetCharacterDataHandler(xml_parser->ctxt, NULL) ; XML_SetXmlDeclHandler(xml_parser->ctxt, NULL) ; XML_SetStartDoctypeDeclHandler(xml_parser->ctxt, NULL) ; if (fire_error_handler) { xmlg_parser_line_and_column(xml_parser, &line, &column) ; /* only ever invoke the error handler once */ if (c->parse_error_cb != NULL && fire_error_handler && ! c->success_abort) c->parse_error_cb(xml_parser, xmlg_fc_get_uri(filter_chain), line, column, detail, detail_len) ; } if (! c->success_abort) c->error_abort = TRUE ; }
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); };
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); } }
/* ============================================================================ * Abort and information functions. */ void xmlg_p_abort_parse( xmlGParser *xml_parser) { xmlGParserCommon *c; XMLGASSERT(xml_parser != NULL, "xml_parser is NULL"); c = xmlg_get_parser_common(xml_parser); XMLGASSERT(c != NULL, "common is NULL"); c->success_abort = TRUE; /* setting the callback functions to NULL ensures we stop */ XML_SetElementHandler(xml_parser->ctxt, NULL, NULL); XML_SetStartNamespaceDeclHandler(xml_parser->ctxt, NULL); XML_SetCharacterDataHandler(xml_parser->ctxt, NULL); XML_SetXmlDeclHandler(xml_parser->ctxt, NULL) ; XML_SetStartDoctypeDeclHandler(xml_parser->ctxt, NULL) ; }
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 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; }
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; }
bool f_xml_set_start_namespace_decl_handler(CObjRef parser, CVarRef handler) { XmlParser * p = parser.getTyped<XmlParser>(); xml_set_handler(&p->startNamespaceDeclHandler, handler); XML_SetStartNamespaceDeclHandler(p->parser, _xml_startNamespaceDeclHandler); return true; }
/* ============================================================================ * Create/Destroy XML parse handler. */ HqBool xmlg_p_new( xmlGContext *xml_ctxt, xmlGParser **xml_parser, xmlGMemoryHandler *memory_handler, xmlGFilterChain *filter_chain) { xmlGParser *new_xml_parser; XMLGASSERT(xml_ctxt != NULL, "xml_ctxt is NULL"); XMLGASSERT(xml_parser != NULL, "xml_parser is NULL"); XMLGASSERT(filter_chain != NULL, "filter_chain is NULL"); *xml_parser = NULL; /* Although this code is going to be common to all back end XML parsers, we need to do it here because only this file knows about the size of xmlGParser - which is back end specific. */ if (memory_handler != NULL) { if (memory_handler->f_malloc == NULL || memory_handler->f_realloc == NULL || memory_handler->f_free == NULL) { XMLGASSERT(FALSE, "incomplete memory handler") ; return FALSE ; } /* Use the pluged memory handler to allocate this structure */ if ((new_xml_parser = memory_handler->f_malloc(sizeof(xmlGParser))) == NULL) return FALSE; } else { /* use the XML sub-system memory management */ if ((new_xml_parser = xmlg_subsystem_malloc(xml_ctxt, sizeof(xmlGParser))) == NULL) return FALSE; } if (! xmlg_parser_common_init(new_xml_parser, xml_ctxt, memory_handler, filter_chain)) { /* We need to do this as we don't know if the memory handlers have been plugged successfuly. Better safe than sorry. */ if (memory_handler != NULL) { memory_handler->f_free(new_xml_parser); } else { xmlg_subsystem_free(xml_ctxt, new_xml_parser); } return FALSE; } /* xmlg_parser_malloc and friends are now available for this handler. */ /* Do backend XML parser specific stuff. */ /* setup expat memory handler structure */ if (memory_handler != NULL) { new_xml_parser->expat_mem.malloc_fcn = memory_handler->f_malloc ; new_xml_parser->expat_mem.realloc_fcn = memory_handler->f_realloc ; new_xml_parser->expat_mem.free_fcn = memory_handler->f_free ; } else { new_xml_parser->expat_mem.malloc_fcn = xml_ctxt->memory_handler.f_malloc ; new_xml_parser->expat_mem.realloc_fcn = xml_ctxt->memory_handler.f_realloc ; new_xml_parser->expat_mem.free_fcn = xml_ctxt->memory_handler.f_free ; } new_xml_parser->ctxt = XML_ParserCreate_MM(NULL, &new_xml_parser->expat_mem, &sep); if (new_xml_parser->ctxt == NULL) { xmlg_parser_free(new_xml_parser, new_xml_parser); return FALSE; } /* Turn prefix mapping on. */ XML_SetReturnNSTriplet(new_xml_parser->ctxt, 1); XML_SetUserData(new_xml_parser->ctxt, (void *)(new_xml_parser)) ; XML_SetElementHandler(new_xml_parser->ctxt, expat_start_element_ns_cb, expat_end_element_ns_cb) ; XML_SetStartNamespaceDeclHandler(new_xml_parser->ctxt, expat_start_namespace_cb) ; XML_SetCharacterDataHandler(new_xml_parser->ctxt, expat_characters_data_cb) ; XML_SetXmlDeclHandler(new_xml_parser->ctxt, expat_xml_decl_cb) ; XML_SetStartDoctypeDeclHandler(new_xml_parser->ctxt, expat_xml_dtd_cb) ; if (filter_chain != NULL) { xmlg_p_set_parse_error_cb(new_xml_parser, filter_chain->parse_error_cb) ; } *xml_parser = new_xml_parser; return TRUE; }
void _Expat_XML_SetStartNamespaceDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartNamespaceDeclHandler start) { XML_SetStartNamespaceDeclHandler(parser, start); }
void XMLParser::EnableStartNamespaceDeclHandler(bool enable) { assert(m_parser != NULL); XML_SetStartNamespaceDeclHandler(m_parser, enable ? StartNamespaceDeclHandler : NULL); }
bool f_xml_set_start_namespace_decl_handler(const Resource& parser, const Variant& handler) { XmlParser * p = parser.getTyped<XmlParser>(); xml_set_handler(&p->startNamespaceDeclHandler, handler); XML_SetStartNamespaceDeclHandler(p->parser, _xml_startNamespaceDeclHandler); return true; }
void bmx_expat_XML_SetStartNamespaceDeclHandler(XML_Parser parser) { XML_SetStartNamespaceDeclHandler(parser, bmx_expat_StartNamespaceDeclHandler); }