/************************************************************************ * 函数名: my_xml_parse * 作 者: sx * 描 述: 1.封装了expat的解析函数,供xml2struct内部调用 * 2.内部函数 * 输入参数: PARSER_FUN_PARAM *pf,数据集合 * char *xml_string,顾名思义 * 输出参数: 无 * 返回值: 0表示成功,>0表示错误编号 ************************************************************************/ int my_xml_parse(PARSER_FUN_PARAM *pf, char *xml_string, int xml_len) { XML_Parser p; p = XML_ParserCreate( NULL ); if (!p) { logger(TLOG_ERROR, "XML_ParserCreate failed!\n" ); return -1; } // logger(TLOG_NOTICE, "XML_ParserCreate success!\n" ); /* 向句柄上设定准备开始和结束签条 */ XML_SetElementHandler( p, start_xml, end_xml ); /* 设置元素内文本的处理函数 */ XML_SetCharacterDataHandler( p, chardatahandle ); /* 一次性解析完 */ //xml_len = strlen( xml_string ); /* 设置一个共享的数据结构给各各处理函数使用 */ XML_SetUserData( p, pf ); /* 把GBK,GB2312等不识别的编码,过滤掉,因为目前仅认为传过来的是英文 */ XML_SetUnknownEncodingHandler( p, XMLEncodingHandle, 0 ); if (XML_Parse( p, xml_string, xml_len, 1 ) == XML_STATUS_ERROR) { #if 1 logger(TLOG_ERROR, "Parse error at line %" XML_FMT_INT_MOD "u:\n%s\n", XML_GetCurrentLineNumber( p ), XML_ErrorString(XML_GetErrorCode( p ) ) ); /* 释放被解析器使用的内存。*/ #endif XML_ParserFree( p ); logger(TLOG_ERROR, "XML_Parse failed!\n" ); return -1; } /* 释放被解析器使用的内存。*/ XML_ParserFree( p ); return pf->ret_err; }
static void PullAllNewsItems(urlconnection *urlconn, rssFeedData *dataPtr) { streamtokenizer st; char buffer[2048]; XML_Parser rssFeedParser = XML_ParserCreate(NULL); XML_SetUserData(rssFeedParser, dataPtr); XML_SetElementHandler(rssFeedParser, ProcessStartTag, ProcessEndTag); XML_SetCharacterDataHandler(rssFeedParser, ProcessTextData); STNew(&st, urlconn->dataStream, "\n", false); while (STNextToken(&st, buffer, sizeof(buffer))) { XML_Parse(rssFeedParser, buffer, strlen(buffer), false); } STDispose(&st); XML_Parse(rssFeedParser, "", 0, true); XML_ParserFree(rssFeedParser); }
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 */
APR_DECLARE(apr_xml_parser *) apr_xml_parser_create_ex(apr_pool_t *pool, void *start_func, void *end_func, void *cdata_func) { apr_xml_parser *parser = apr_pcalloc(pool, sizeof(*parser)); parser->impl = apr_xml_get_parser_impl(); parser->p = pool; parser->doc = apr_pcalloc(pool, sizeof(*parser->doc)); parser->doc->namespaces = apr_array_make(pool, 5, sizeof(const char *)); /* ### is there a way to avoid hard-coding this? */ apr_xml_insert_uri(parser->doc->namespaces, APR_KW_DAV); parser->xp = XML_ParserCreate(NULL); if (parser->xp == NULL) { (*apr_pool_abort_get(pool))(APR_ENOMEM); return NULL; } apr_pool_cleanup_register(pool, parser, cleanup_parser, apr_pool_cleanup_null); XML_SetUserData(parser->xp, parser); XML_SetElementHandler(parser->xp, start_func, end_func); XML_SetCharacterDataHandler(parser->xp, cdata_func); /* 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, installing a noop * DefaultHandler means that internal entities will be expanded as * the empty string, which is also sufficient to prevent the * attack. */ #if XML_MAJOR_VERSION > 1 XML_SetEntityDeclHandler(parser->xp, entity_declaration); #else XML_SetDefaultHandler(parser->xp, default_handler); #endif return parser; }
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'); XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl); } else if (dynamic_cast<NamespacePrefixesStrategy*>(_pNamespaceStrategy)) { _parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t'); XML_SetReturnNSTriplet(_parser, 1); XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl); } else { _parser = XML_ParserCreate(_encodingSpecified ? _encoding.c_str() : 0); } 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); }
////////////////////////////////////////////////////////////////////////////////// /// Parse the fmu. The receiver must call freeElement(md) to release AST memory. /// ///\param xmlPath The xml file to be parsed ///\return the root node md of the AST if no error occurred. NULL to indicate failure ///////////////////////////////////////////////////////////////////////////////// ModelDescription* parse(const char* xmlPath) { ModelDescription* md = NULL; FILE *file; int done = 0; stack = stackNew(100, 10); // Allocate stack memory if (checkPointer(stack)) return NULL; // Check if the stack is creatted parser = XML_ParserCreate(NULL); // Create an parser if (checkPointer(parser)) return NULL; // Check if the parser is created XML_SetElementHandler(parser, startElement, endElement); // Set handler for start and end tags XML_SetCharacterDataHandler(parser, handleData); // Set handler for text file = fopen(xmlPath, "rb"); if (file == NULL) { printfError("Cannot open file '%s'\n", xmlPath); XML_ParserFree(parser); // Free the memory for parser return NULL; // Failure } while (!done) { int n = fread(text, sizeof(char), XMLBUFSIZE, file); // Read XMLBUFSIZE characters from file if (n != XMLBUFSIZE) done = 1; // Reach the end of file if (!XML_Parse(parser, text, n, done)){ printf("Parse error in file %s at line %d:\n%s\n", xmlPath, (int)XML_GetCurrentLineNumber(parser), XML_ErrorString(XML_GetErrorCode(parser))); while (!stackIsEmpty(stack)) md = stackPop(stack); if (md) freeElement(md); cleanup(file); return NULL; // failure } } md = stackPop(stack); assert(stackIsEmpty(stack)); cleanup(file); //printElement(1, md); // Print the element for debugging return md; // Success if all refs are valid }
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); }
static void controlanswer_stop_callback( void *data, const char *el) { struct controlanswer_parsercontext *context = (struct controlanswer_parsercontext *)data; (void)el; switch(context->state) { case START: context->state = MALFORMED; break; case END: break; case CONTROLANSWER: context->state = END; break; case CONTROLANSWER_VARIABLE: case CONTROLANSWER_OTHER: context->state = CONTROLANSWER; break; case CONTROLANSWER_VARIABLE_VALUE: XML_SetCharacterDataHandler( context->parser, NULL); case CONTROLANSWER_VARIABLE_OTHER: context->state = CONTROLANSWER_VARIABLE; break; default: context->state = MALFORMED; break; } if (context->state == MALFORMED) { XML_SetElementHandler( context->parser, NULL, NULL); } }
BOOL loadconfig (config_t * currentconfig, const char *filename) { FILE *fp; char *contents; unsigned int len; config_init_config (currentconfig); if (filename) fp = fopen (filename, "r"); else fp = fopen (sysconfdir "/antinat.xml", "r"); if (!fp) return FALSE; fseek (fp, 0, SEEK_END); len = ftell (fp); fseek (fp, 0, SEEK_SET); contents = (char *) malloc (len); if (contents == NULL) { fclose (fp); return FALSE; } if (fread (contents, 1, len, fp) == 0) { free (contents); fclose (fp); return FALSE; } fclose (fp); p = XML_ParserCreate (NULL); XML_SetElementHandler (p, config_xml_start, config_xml_end); XML_SetUserData (p, currentconfig); XML_Parse (p, contents, len, 1); XML_ParserFree (p); free (contents); return TRUE; }
static void propclose(void *dat, const XML_Char *s) { struct parse *p = dat; enum calelem elem; switch ((elem = calelem_find(s))) { case (CALELEM__MAX): break; case (CALELEM_PROP): XML_SetElementHandler(p->xp, parseopen, parseclose); break; default: if (PROP__MAX == calprops[elem]) break; propadd(p, s, calprops[elem], p->buf.buf); XML_SetDefaultHandler(p->xp, NULL); break; } }
int feed_init(struct feed **feedp, struct evbuffer *sink) { struct feed *feed; if ((feed = malloc(sizeof(*feed))) == NULL) { return ENOMEM; } memset(feed, 0, sizeof(*feed)); feed->parser = XML_ParserCreate(NULL); XML_SetUserData(feed->parser, feed); XML_SetElementHandler(feed->parser, element_start, element_end); XML_SetCharacterDataHandler(feed->parser, cdata); feed->sink = sink; *feedp = feed; return 0; }
const char* hxcfe_getXmlLayoutName(XmlFloppyBuilder* context,int moduleID) { AppData *ad = (AppData *) context->ad; if(hxcfe_numberOfXmlLayout(context) > moduleID) { ad->xmlcheck = 1; XML_ParserReset(context->xml_parser, NULL); XML_SetUserData(context->xml_parser, (void *) ad); XML_SetElementHandler(context->xml_parser, start, end); XML_SetCharacterDataHandler(context->xml_parser, charhandler); XML_SetNamespaceDeclHandler(context->xml_parser, ns_start, ns_end); XML_Parse(context->xml_parser, disklayout_list[moduleID]->unpacked_data, disklayout_list[moduleID]->size, 1); return (const char*)ad->name; } return NULL; }
/// do actual parse, firing events a& returning true if all went well /// need to create expat parser each time we dparse as its a one shot device bool ParserImpl :: Parse( const string & s ) { if ( mExpat ) { XML_ParserFree( mExpat ); } mExpat = XML_ParserCreate( 0 ); XML_SetElementHandler( mExpat, StartElementHandler, EndElementHandler ); XML_SetCharacterDataHandler( mExpat, CharDataHandler ); XML_SetUserData( mExpat, this ); unsigned int err = XML_Parse( mExpat, s.c_str(), s.size(), 1 ); if ( err == 0 ) { mErrorCode = XML_GetErrorCode( mExpat ); mErrorMsg = XML_ErrorString( XML_Error( err ) ); mErrorLine = XML_GetCurrentLineNumber( mExpat ); } return err != 0; }
static void PullAllNewsItems(rssDatabase *db, urlconnection *urlconn) { rssFeedState state = {db}; // passed through the parser by address as auxiliary data. streamtokenizer st; char buffer[2048]; XML_Parser rssFeedParser = XML_ParserCreate(NULL); XML_SetUserData(rssFeedParser, &state); XML_SetElementHandler(rssFeedParser, ProcessStartTag, ProcessEndTag); XML_SetCharacterDataHandler(rssFeedParser, ProcessTextData); STNew(&st, urlconn->dataStream, "\n", false); while (STNextToken(&st, buffer, sizeof(buffer))) { XML_Parse(rssFeedParser, buffer, strlen(buffer), false); } STDispose(&st); XML_Parse(rssFeedParser, "", 0, true); // instructs the xml parser that we're done parsing.. XML_ParserFree(rssFeedParser); }
/* 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; }
plist_item *plist_item_from_file(char *fileName) { FILE *f; int isFinal; user_data u; u.s = (char *)malloc(1); u.s[0] = 0; u.key = (char *)malloc(1); u.key[0] = 0; XML_Parser xml = XML_ParserCreate(NULL); u.xml = xml; XML_SetUserData(xml,&u); XML_SetElementHandler(xml,startElement,endElement); XML_SetCharacterDataHandler(xml,charHandler); f = fopen(fileName,"r"); if (f) { char buffer[BUF_SIZE]; int firstRun=1; do { int bytesRead = fread(buffer,1,BUF_SIZE,f); if(firstRun==1 && bytesRead==0) { XML_ParserFree(xml); free(u.root); return NULL; } else firstRun=0; isFinal = !(bytesRead==BUF_SIZE); XML_Parse(xml,buffer,bytesRead,isFinal); } while (!isFinal); fclose(f); } else { fprintf(stderr,"plist_item_from_file(): Couldn't open file %s\n",fileName); XML_ParserFree(xml); free(u.root); return NULL; } XML_ParserFree(xml); free(u.key); free(u.s); return u.root; }
static int lxp_make_parser (lua_State *L) { XML_Parser p; char sep = *luaL_optstring(L, 2, ""); lxp_userdata *xpu = createlxp(L); 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); 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; }
int Encode (CFileReader &p_coFileReader) { int iRetVal = 0; XML_Parser psoParser; psoParser = XML_ParserCreate ("UTF-8"); if (NULL == psoParser) { iRetVal = ENOMEM; return iRetVal; } SDoc soDoc; /* регистрация обработчика данных */ XML_SetElementHandler (psoParser, StartElementHandler, EndElementHandler); XML_SetXmlDeclHandler (psoParser, XmlDeclHandler); XML_SetDoctypeDeclHandler (psoParser, StartDoctypeDeclHandler, EndDoctypeDeclHandler); XML_SetUserData (psoParser, &soDoc); /* парсинг данных */ char mcBuf[256]; int iDataLen; int iIsFinal = 0; do { iDataLen = sizeof (mcBuf); if (p_coFileReader.ReadData ((unsigned char*)mcBuf, iDataLen)) iIsFinal = 1; XML_Parse (psoParser, mcBuf, iDataLen, iIsFinal); if (iIsFinal) break; } while (1); Tokenize (soDoc); if (psoParser) { XML_ParserFree (psoParser); psoParser = NULL; } return iRetVal; }
bool Graph::graphload(FILE * fptr) { const int BUFFSIZE = 2000; char buffer[BUFFSIZE]; int done; int len; bool result; XML_Parser p = XML_ParserCreate(NULL); if (! p) { fprintf(stderr, "Couldn't allocate memory for parser\n"); return false; } XML_SetUserData(p, this); XML_SetElementHandler(p, Graph::startGraphTag, Graph::endGraphTag); do { len = fread(buffer, 1, BUFFSIZE, fptr); printf("Read length = %d\n", len); if (ferror(fptr)) { fprintf(stderr, "Read error\n"); return false; } done = feof(fptr); if (! XML_Parse(p, buffer, len, done)) { fprintf(stderr, "Parse error at line %d:\n%s\n", (int) XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p))); fclose(fptr); return false; } } while(!done); XML_ParserFree(p); result = rootNode.connectEdges(); return result; }
void LLSDXMLParser::Impl::reset() { mResult.clear(); mParseCount = 0; mInLLSDElement = false; mDepth = 0; mGracefullStop = false; mStack.clear(); mSkipping = false; mCurrentKey.clear(); XML_ParserReset(mParser, "utf-8"); XML_SetUserData(mParser, this); XML_SetElementHandler(mParser, sStartElementHandler, sEndElementHandler); XML_SetCharacterDataHandler(mParser, sCharacterDataHandler); }
FLOPPY* hxcfe_generateXmlFloppy (XmlFloppyBuilder* context,unsigned char * rambuffer,unsigned buffersize) { AppData *ad; ad = context->ad; ad->xmlcheck = 0; ad->image_data = rambuffer; ad->buffer_size = buffersize; XML_ParserReset(context->xml_parser, NULL); XML_SetUserData(context->xml_parser, (void *) ad); XML_SetElementHandler(context->xml_parser, start, end); XML_SetCharacterDataHandler(context->xml_parser, charhandler); XML_SetNamespaceDeclHandler(context->xml_parser, ns_start, ns_end); XML_Parse(context->xml_parser, disklayout_list[ad->layout_id]->unpacked_data, disklayout_list[ad->layout_id]->size, 1); return ad->floppy; }
bool SkXMLPullParser::onInit() { fImpl = new Impl; XML_Parser p = XML_ParserCreate(NULL); SkASSERT(p); fImpl->fData.fParser = p; fImpl->fData.fCurr = &fCurr; XML_SetElementHandler(p, start_proc, end_proc); XML_SetCharacterDataHandler(p, text_proc); XML_SetUserData(p, &fImpl->fData); size_t len = fStream->read(NULL, 0); fImpl->fBufferLen = len; fImpl->fBuffer = sk_malloc_throw(len); fStream->rewind(); size_t len2 = fStream->read(fImpl->fBuffer, len); return len2 == len; }
CDOMDocument::CDOMDocument() { this->onKeyword = NULL; this->currentNode = this->documentElement = NULL; this->path = NULL; this->upath = NULL; this->path_msize = 0; this->upath_msize = 0; this->onStart = NULL; this->onEnd = NULL; this->onKeyword = NULL; if( (this->parser = XML_ParserCreate(NULL)) ) { XML_SetUserData(this->parser, this); XML_SetElementHandler(this->parser, this->start, this->end ); XML_SetCharacterDataHandler(this->parser, this->charHandler); XML_SetCdataSectionHandler(this->parser, this->startCdata, this->endCdata); } }
Component::Component(const char *hostname, const char *port, const char *component_name, const char *password, bool silent): ExpatWrapper(), socket(), stack() { this->hostname = strdup(hostname); this->port = strdup(port); this->component_name = strdup(component_name); this->password = strdup(password); parser = XML_ParserCreate((XML_Char *) "UTF-8"); XML_SetUserData(parser, (void*) this); XML_SetElementHandler(parser, startElementCallback, endElementCallback); XML_SetCharacterDataHandler(parser, characterDataCallback); depth = 0; presence_handler = 0; message_handler = 0; iq_query_handler = 0; auth_success_handler = 0; stream_error_handler = 0; exit_code = 0; this->silent = silent; }
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; }
static void add_code11_product(struct parsedata *pd, FILE *fp) { char buf[BUFF_SIZE]; int l; struct stat st; XML_Parser parser; if (!fstat(fileno(fp), &st)) { pd->currentproduct = st.st_ino; pd->ctime = (unsigned int)st.st_ctime; } else { pd->currentproduct = pd->baseproduct + 1; /* make it != baseproduct if stat fails */ pool_error(pd->pool, 0, "fstat: %s", strerror(errno)); pd->ctime = 0; } parser = XML_ParserCreate(NULL); XML_SetUserData(parser, pd); XML_SetElementHandler(parser, startElement, endElement); XML_SetCharacterDataHandler(parser, characterData); for (;;) { l = fread(buf, 1, sizeof(buf), fp); if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR) { pool_debug(pd->pool, SOLV_ERROR, "%s: %s at line %u:%u\n", pd->filename, XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser)); pool_debug(pd->pool, SOLV_ERROR, "skipping this product\n"); XML_ParserFree(parser); return; } if (l == 0) break; } XML_ParserFree(parser); }
/** * Parse an XML string into a nested list. * The second parameter indicates if body text (text within XML tags) * should show up among the children of the tag or in its own * section. * * See documentation (ext-xml.README) for examples. */ static package parse_xml(const char *data, int bool_stream) { /* * FIXME: Feed expat smaller chunks of the string and * check for task timeout between chunks * */ int decoded_length; const char *decoded; package result; XML_Parser parser = XML_ParserCreate(NULL); XMLdata *root = new_node(NULL, ""); XMLdata *child = root; decoded_length = strlen(data); decoded = data; XML_SetUserData(parser, &child); XML_SetElementHandler(parser, xml_startElement, xml_endElement); if(bool_stream) { XML_SetCharacterDataHandler(parser, xml_streamCharacterDataHandler); } else { XML_SetCharacterDataHandler(parser, xml_characterDataHandler); } if (!XML_Parse(parser, decoded, decoded_length, 1)) { Var r; r.type = TYPE_INT; r.v.num = XML_GetCurrentByteIndex(parser); flush_nodes(child); result = make_raise_pack(E_INVARG, XML_ErrorString(XML_GetErrorCode(parser)), r); } else { finish_node(root); result = make_var_pack(var_ref(root->element.v.list[4].v.list[1])); free_node(root); } XML_ParserFree(parser); return result; }
static int setup_parser(xml_parse_info *parse_info, xml_parse_options *opts) { /* setup parse_info structure */ memset(parse_info, 0, sizeof(*parse_info)); if (opts) { parse_info->flags = opts->flags; if (opts->error) { opts->error->error_message = NULL; opts->error->error_line = 0; opts->error->error_column = 0; } } /* create a root node */ parse_info->rootnode = xml_file_create(); if (!parse_info->rootnode) return FALSE; parse_info->curnode = parse_info->rootnode; /* create the XML parser */ parse_info->parser = XML_ParserCreate(NULL); if (!parse_info->parser) { free(parse_info->rootnode); return FALSE; } /* configure the parser */ XML_SetElementHandler(parse_info->parser, xml_element_start, xml_element_end); XML_SetCharacterDataHandler(parse_info->parser, xml_data); XML_SetUserData(parse_info->parser, parse_info); /* optional parser initialization step */ if (opts && opts->init_parser) opts->init_parser(parse_info->parser); return TRUE; }
int64_t f_xml_parse_into_struct(CObjRef parser, CStrRef data, VRefParam values, VRefParam index /* = null */) { int ret; XmlParser * p = parser.getTyped<XmlParser>(); values = Array::Create(); p->data.assignRef(values); index = Array::Create(); p->info.assignRef(index); p->level = 0; p->ltags = (char**)malloc(XML_MAXLEVEL * sizeof(char*)); XML_SetDefaultHandler(p->parser, _xml_defaultHandler); XML_SetElementHandler(p->parser, _xml_startElementHandler, _xml_endElementHandler); XML_SetCharacterDataHandler(p->parser, _xml_characterDataHandler); p->isparsing = 1; ret = XML_Parse(p->parser, (const XML_Char*)data.data(), data.size(), 1); p->isparsing = 0; return ret; }