mzpSAXHandler::mzpSAXHandler() { fptr = NULL; m_bGZCompression = false; fptr = NULL; m_parser = XML_ParserCreate(NULL); XML_SetUserData(m_parser, this); XML_SetElementHandler(m_parser, mzp_startElementCallback, mzp_endElementCallback); XML_SetCharacterDataHandler(m_parser, mzp_charactersCallback); }
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."; }
QgsGPSData* QgsGPSData::getData( const QString& fileName ) { // if the data isn't there already, try to load it if ( dataObjects.find( fileName ) == dataObjects.end() ) { QFile file( fileName ); if ( !file.open( QIODevice::ReadOnly ) ) { QgsLogger::warning( QObject::tr( "Couldn't open the data source: %1" ).arg( fileName ) ); return 0; } QgsGPSData* data = new QgsGPSData; QgsDebugMsg( "Loading file " + fileName ); QgsGPXHandler handler( *data ); bool failed = false; // SAX parsing XML_Parser p = XML_ParserCreate( NULL ); XML_SetUserData( p, &handler ); XML_SetElementHandler( p, QgsGPXHandler::start, QgsGPXHandler::end ); XML_SetCharacterDataHandler( p, QgsGPXHandler::chars ); long int bufsize = 10 * 1024 * 1024; char* buffer = new char[bufsize]; int atEnd = 0; while ( !file.atEnd() ) { long int readBytes = file.read( buffer, bufsize ); if ( file.atEnd() ) atEnd = 1; if ( !XML_Parse( p, buffer, readBytes, atEnd ) ) { QgsLogger::warning( QObject::tr( "Parse error at line %1 : %2" ) .arg( XML_GetCurrentLineNumber( p ) ) .arg( XML_ErrorString( XML_GetErrorCode( p ) ) ) ); failed = true; break; } } delete [] buffer; XML_ParserFree( p ); if ( failed ) return 0; data->setNoDataExtent(); dataObjects[fileName] = std::pair<QgsGPSData*, unsigned>( data, 0 ); } else QgsDebugMsg( fileName + " is already loaded" ); // return a pointer and increase the reference count for that file name DataMap::iterator iter = dataObjects.find( fileName ); ++( iter->second.second ); return ( QgsGPSData* )( iter->second.first ); }
xml_t * XSD_Variable_LoadFromHandle(FILE *f, int filelen) { #else xml_t * XSD_Variable_LoadFromHandle(vfsfile_t *v, int filelen) { vfserrno_t err; #endif xml_variable_t *document; XML_Parser parser = NULL; int len; int pos = 0; char buf[XML_READ_BUFSIZE]; xml_parser_stack_t parser_stack; // create blank document document = (xml_variable_t *) Q_malloc(sizeof(xml_variable_t)); XSD_Variable_Init(document); // initialize XML parser parser = XML_ParserCreate(NULL); if (parser == NULL) goto error; XML_SetStartElementHandler(parser, OnStartElement); XML_SetEndElementHandler(parser, OnEndElement); XML_SetCharacterDataHandler(parser, OnCharacterData); // prepare user data XSD_InitStack(&parser_stack); parser_stack.document = (xml_t *) document; XML_SetUserData(parser, &parser_stack); #ifndef WITH_FTE_VFS while ((len = fread(buf, 1, min(XML_READ_BUFSIZE, filelen-pos), f)) > 0) #else while ((len = VFS_READ(v, buf, min(XML_READ_BUFSIZE, filelen-pos), &err)) > 0) #endif { if (XML_Parse(parser, buf, len, 0) != XML_STATUS_OK) goto error; pos += len; } if (XML_Parse(parser, NULL, 0, 1) != XML_STATUS_OK) goto error; XML_ParserFree(parser); return (xml_t *) document; error: if (parser) XML_ParserFree(parser); XSD_Variable_Free((xml_t *)document); return NULL; }
int gamelist_load(void) { XML_Parser parser = XML_ParserCreate(NULL); FILE *f; int depth = 0, done; static char buf[BUFSIZ]; curgame = -1; numgames = 0; games = (M1GameT *)NULL; // realloc() will become malloc() if ptr is NULL, which is handy f = fopen("m1.xml", "r"); if (!f) { return 0; } XML_SetUserData(parser, &depth); XML_SetElementHandler(parser, startElement, endElement); XML_SetCharacterDataHandler(parser, charData); XML_SetUnknownEncodingHandler(parser, unkEncodingHandler, NULL); xml_state = XML_INVALID; do { unsigned int len = fread(buf, 1, sizeof(buf), f); done = (len < sizeof(buf)); if (!XML_Parse(parser, buf, len, done)) { printf("XML parse error %s at line %d (m1.xml)\n", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser)); // clean up XML_ParserFree(parser); if (games) { free(games); games = (M1GameT *)NULL; } return 0; } } while (!done); XML_ParserFree(parser); fclose(f); // printf("Finished loading, %d games\n", numgames); return numgames; }
BOOLEAN ReadInArmyCompositionInfo(STR fileName) { HWFILE hFile; UINT32 uiBytesRead; UINT32 uiFSize; CHAR8 * lpcBuffer; XML_Parser parser = XML_ParserCreate(NULL); compositionParseData pData; // Open weapons file hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE ); if ( !hFile ) return( FALSE ); uiFSize = FileGetSize(hFile); lpcBuffer = (CHAR8 *) MemAlloc(uiFSize+1); //Read in block if ( !FileRead( hFile, lpcBuffer, uiFSize, &uiBytesRead ) ) { MemFree(lpcBuffer); return( FALSE ); } lpcBuffer[uiFSize] = 0; //add a null terminator FileClose( hFile ); XML_SetElementHandler(parser, compositionStartElementHandle, compositionEndElementHandle); XML_SetCharacterDataHandler(parser, compositionCharacterDataHandle); memset(&pData,0,sizeof(pData)); XML_SetUserData(parser, &pData); NUM_ARMY_COMPOSITIONS = 0; if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE)) { CHAR8 errorBuf[511]; sprintf(errorBuf, "XML Parser Error in ArmyComposition.xml: %s at line %d", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser)); LiveMessage(errorBuf); MemFree(lpcBuffer); return FALSE; } MemFree(lpcBuffer); XML_ParserFree(parser); return TRUE; }
TinyDomElement* TinyDom::parse(std::istream& istr) { XML_Parser parser = XML_ParserCreate(0); TinyDomParser tdparser; XML_SetUserData(parser, &tdparser); XML_SetCharacterDataHandler(parser, characterDataHandler); XML_SetElementHandler(parser, startElementHandler, endElementHandler); XML_SetCommentHandler(parser, commentHandler); XML_SetProcessingInstructionHandler(parser, processingInstructionHandler); XML_SetXmlDeclHandler(parser, xmlDeclHandler); XML_SetDefaultHandler(parser, defaultHandler); XML_SetDoctypeDeclHandler(parser, startDoctypeDeclHandler, endDoctypeDeclHandler); try { while (1) { void* buf = XML_GetBuffer(parser, 1024); if (!buf) { throw std::runtime_error("out of memory!"); } istr.read((char*)buf, 1024); std::streamsize len = istr.gcount(); if (istr.fail() && !istr.eof()) { throw std::runtime_error("failed IO"); } bool isFinal = (istr.eof() || len < 1024); if (! XML_ParseBuffer(parser, len, isFinal)) { std::ostringstream ostr; ostr << "parse error at line " << XML_GetErrorLineNumber(parser) << ", column " << XML_GetErrorColumnNumber(parser) << ": " << XML_ErrorString(XML_GetErrorCode(parser)); throw std::runtime_error(ostr.str()); } if (isFinal) { break; } } XML_ParserFree(parser); } catch (...) { //std::cerr << "Got exception: " << e.what() << "\n"; if (parser) { XML_ParserFree(parser); } delete tdparser.rootElement; throw; } return tdparser.rootElement; }
int main(int argc, char **argv) { XML_Parser parser; size_t i; size_t j; nst_cfg_allocator = nst_mem_stat_register("NST CFG"); parser = XML_ParserCreate(NULL); expat_stack_top->parser = parser; if(!parser) { assert(0 && "Cannot allocate memory during XML_ParserCreate\n"); return -1; } for(i = 0; i < sizeof(xml_test_strings) / sizeof(const char *); i++) { const char *xml_test_string = xml_test_strings[i]; enum XML_Status xml_status; XML_SetStartElementHandler(parser, root_start_handler); XML_SetEndElementHandler(parser, root_end_handler); XML_SetCharacterDataHandler(parser, root_char_handler); XML_SetUserData(parser, (void*)&expat_stack_top); for(j = 0; xml_test_string[j]; j++) { xml_status = XML_Parse(parser, xml_test_string+j, 1, 0); if(xml_status != XML_STATUS_OK) { fprintf(stderr, "Parse error at line %lu: %s\n", XML_GetCurrentLineNumber(parser), XML_ErrorString(XML_GetErrorCode(parser))); return -1; } } xml_status = XML_Parse(parser, NULL, 0, 1); if(xml_status != XML_STATUS_OK) { fprintf(stderr, "Parse error at line %lu: %s\n", XML_GetCurrentLineNumber(parser), XML_ErrorString(XML_GetErrorCode(parser))); return -1; } XML_ParserReset(parser, NULL); }; XML_ParserFree(parser); assert(nst_mem_stat_get_allocated_nbytes(nst_cfg_allocator.data) == 0); return 0; }
/* * Public interface */ clish_xmldoc_t *clish_xmldoc_read(const char *filename) { clish_xmldoc_t *doc; struct stat sb; int fd; char *buffer; XML_Parser parser; int rb; doc = malloc(sizeof(clish_xmldoc_t)); if (!doc) return NULL; memset(doc, 0, sizeof(clish_xmldoc_t)); doc->filename = strdup(filename); parser = XML_ParserCreate(NULL); if (!parser) goto error_parser_create; XML_SetUserData(parser, doc); XML_SetCharacterDataHandler(parser, clish_expat_chardata_handler); XML_SetElementHandler(parser, clish_expat_element_start, clish_expat_element_end); fd = open(filename, O_RDONLY); if (fd < 0) goto error_open; fstat(fd, &sb); buffer = malloc(sb.st_size+1); rb = read(fd, buffer, sb.st_size); if (rb < 0) { close(fd); goto error_parse; } buffer[sb.st_size] = 0; close(fd); if (!XML_Parse(parser, buffer, sb.st_size, 1)) goto error_parse; XML_ParserFree(parser); free(buffer); return doc; error_parse: free(buffer); error_open: XML_ParserFree(parser); error_parser_create: clish_xmldoc_release(doc); return NULL; }
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; }
int _xml_papi_hwi_setup_all_presets( char *arch, hwi_dev_notes_t * notes ) { int done = 0; FILE *fp = fopen( "./papi_events.xml", "r" ); XML_Parser p = XML_ParserCreate( NULL ); if ( !p ) { PAPIERROR( "Couldn't allocate memory for XML parser." ); fclose(fp); return ( PAPI_ESYS ); } XML_SetElementHandler( p, _xml_start, _xml_end ); XML_SetCharacterDataHandler( p, _xml_content ); if ( fp == NULL ) { PAPIERROR( "Error opening Preset XML file." ); fclose(fp); return ( PAPI_ESYS ); } xml_arch = arch; do { int len; void *buffer = XML_GetBuffer( p, BUFFSIZE ); if ( buffer == NULL ) { PAPIERROR( "Couldn't allocate memory for XML buffer." ); fclose(fp); return ( PAPI_ESYS ); } len = fread( buffer, 1, BUFFSIZE, fp ); if ( ferror( fp ) ) { PAPIERROR( "XML read error." ); fclose(fp); return ( PAPI_ESYS ); } done = feof( fp ); if ( !XML_ParseBuffer( p, len, len == 0 ) ) { PAPIERROR( "Parse error at line %d:\n%s", XML_GetCurrentLineNumber( p ), XML_ErrorString( XML_GetErrorCode( p ) ) ); fclose(fp); return ( PAPI_ESYS ); } if ( error ) { fclose(fp); return ( PAPI_ESYS ); } } while ( !done ); XML_ParserFree( p ); fclose( fp ); return ( PAPI_OK ); }
static void driver_info_parse(DriverInfo* thiz, char* buffer, size_t length) { XML_Parser parser = XML_ParserCreate(NULL); XML_SetUserData(parser, thiz); XML_SetElementHandler(parser, on_start, on_end); XML_SetCharacterDataHandler(parser, on_text); XML_Parse(parser, buffer, length, TRUE); XML_ParserFree(parser); return; }
ExpatParser::ExpatParser() : mHandler(NULL) { mExpat = XML_ParserCreate(NULL); if (mExpat) { XML_SetUserData(mExpat, this); XML_SetDoctypeDeclHandler(mExpat, startDoctypeWrapper, endDoctypeWrapper); XML_SetElementHandler(mExpat, startElementWrapper, endElementWrapper); XML_SetCharacterDataHandler(mExpat, charactersWrapper); } }
PRIVATE void HTXML_setHandlers (XML_Parser me) { XML_SetElementHandler(me, XML_startElement, XML_endElement); XML_SetCharacterDataHandler(me, XML_characterData); XML_SetProcessingInstructionHandler(me, XML_processingInstruction); XML_SetDefaultHandler(me, XML_default); XML_SetUnparsedEntityDeclHandler(me, XML_unparsedEntityDecl); XML_SetNotationDeclHandler(me, XML_notationDecl); XML_SetExternalEntityRefHandler(me, XML_externalEntityRef); XML_SetUnknownEncodingHandler(me, XML_unknownEncoding, NULL); }
xode xode_from_file(char *file) { XML_Parser p; xode *x, node; /* pointer to an xmlnode */ char buf[BUFSIZ]; int done, fd, len; char _file[1000]; if(NULL == file) return NULL; /* perform tilde expansion */ if(*file == '~') { char *env = getenv("HOME"); if(env != NULL) snprintf((char*)_file, 1000, "%s%s", env, file + 1); else snprintf((char*)_file, 1000, "%s", file); } else { snprintf((char*)_file, 1000, "%s", file); } fd = open((char*)&_file,O_RDONLY); if(fd < 0) return NULL; x = malloc(sizeof(void *)); *x = NULL; /* pointer to NULL */ p = XML_ParserCreate(NULL); XML_SetUserData(p, x); XML_SetElementHandler(p, _xode_expat_startElement, _xode_expat_endElement); XML_SetCharacterDataHandler(p, _xode_expat_charData); do{ len = read(fd, buf, BUFSIZ); done = len < BUFSIZ; if(!XML_Parse(p, buf, len, done)) { /* jdebug(ZONE,"xmlnode_file_parseerror: %s",(char *)XML_ErrorString(XML_GetErrorCode(p)));*/ xode_free(*x); *x = NULL; done = 1; } }while(!done); node = *x; XML_ParserFree(p); free(x); close(fd); return node; /* return the xmlnode x points to */ }
static void run_character_check(XML_Char *text, XML_Char *expected) { CharData storage; CharData_Init(&storage); XML_SetUserData(parser, &storage); XML_SetCharacterDataHandler(parser, accumulate_characters); if (XML_Parse(parser, text, strlen(text), 1) == XML_STATUS_ERROR) xml_failure(parser); CharData_CheckXMLChars(&storage, expected); }
static void got_api(struct evhttp_request* req, void* userdata) { struct req_data* d = (struct req_data*) userdata; if(req->response_code != 200) { evhttp_send_error(d->req, 500, "Internal Server Error"); free_req_data(&d); fprintf(stderr, "info.c:got_api(): api returned http status %d\n", (int)(req->response_code)); return; } XML_Parser parser = XML_ParserCreate(NULL); int done; int depth = 0; XML_SetUserData(parser, d); XML_SetElementHandler(parser, startElement, endElement); XML_SetCharacterDataHandler(parser, xmlData); char buf[4096]; int buflen; while((buflen = evbuffer_remove(req->input_buffer, buf, 4096)) > 0) { if(XML_Parse(parser, buf, buflen, 0) == XML_STATUS_ERROR) { evhttp_send_error(d->req, 500, "Internal Server Error"); free_req_data(&d); fprintf(stderr, "info.c:got_api(): error parsing xml: %s\n", XML_ErrorString(XML_GetErrorCode(parser))); return; } } XML_ParserFree(parser); // return static result struct evbuffer *evbuf; evbuf = evbuffer_new(); if (buf == NULL) { evhttp_send_error(d->req, 500, "Internal Server Error"); free_req_data(&d); fprintf(stderr, "info.c:got_api(): couldn't alloc evbuffer\n"); return; } evhttp_remove_header(d->req->output_headers, "content-type"); evhttp_add_header(d->req->output_headers, "content-type", "application/json"); evhttp_add_header(d->req->output_headers, "cache-control", "no-cache"); evbuffer_add_printf(evbuf, "{ \"eventName\": \"%s\", \"description\": \"%s\", \"serverTime\": %d, \"startTime\": %d, \"duration\": %d, \"login\": \"%s\", \"title\": \"%s\", \"profile_image\": \"%s\" }\n", d->event_title, d->description, (int)time(0), (int)(d->start), d->duration, d->login, d->channel_title, d->profile_image); evhttp_send_reply(d->req, 200, "OK", evbuf); evbuffer_free(evbuf); free_req_data(&d); }
int main(int argc, char **argv) { // int res = isatty(fileno( stdin)); // // if(!res){ // fprintf(stderr, "Must provide input document on stdin\n"); // exit(1); // } XML_Parser p = XML_ParserCreate(NULL); if (!p) { fprintf(stderr, "Couldn't allocate memory for parser\n"); exit(-1); } XML_UseParserAsHandlerArg(p); XML_SetElementHandler(p, start_hndl, end_hndl); XML_SetCharacterDataHandler(p, char_hndl); XML_SetProcessingInstructionHandler(p, proc_hndl); /* Notice that the default handler is not set at this point */ for (;;) { int done; int len; fgets(Buff, sizeof(Buff), stdin); len = strlen(Buff); if (ferror(stdin)) { fprintf(stderr, "Read error\n"); exit(-1); } done = feof(stdin); if (XML_Parse(p, Buff, len, done) != XML_STATUS_OK) { fprintf(stderr, "Parse error at line %lu :\n %s \n", XML_GetCurrentLineNumber(p), XML_ErrorString( XML_GetErrorCode(p))); exit(-1); } if (done) break; } printf("\n"); return 0; } /* End main */
//----------------------------------------------------------------------- void ExpatParser::parseXMLFile(XMLHandler& handler, const Ogre::String& xmlName, const Ogre::String& xmlResourceGroup, const Ogre::String& schemaName, const Ogre::String& schemaResourceGroup) { XML_Parser parser = XML_ParserCreate(NULL); try { MyUserData myUserData; myUserData.handler = &handler; if (_locale.get()) myUserData.converter = boost::bind(&expat_to_local, _1, _2, boost::ref(*_locale)); else myUserData.converter = boost::bind(&expat_to_local_win32, _1, _2, boost::ref(_buffer)); XML_SetUserData(parser, &myUserData); XML_SetElementHandler(parser, expatStartElementHandler, expatEndElementHandler); XML_SetCharacterDataHandler(parser, expatCharacterDataHandler); const size_t MaxBufferSize = 64*1024; Ogre::DataStreamPtr dataStream = Ogre::ResourceGroupManager::getSingleton().openResource(xmlName, xmlResourceGroup); bool done; do { void* buffer = XML_GetBuffer(parser, MaxBufferSize); if (!buffer) { OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR, "Can't allocate buffer while parse XML file '" + xmlName + "'.", "ExpatParser::parseXMLFile"); } size_t count = dataStream->read(buffer, MaxBufferSize); done = dataStream->eof(); if (XML_ParseBuffer(parser, count, done) != XML_STATUS_OK) { OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR, "An error occurred while parsing XML file '" + xmlName + "' at line " + Ogre::StringConverter::toString(XML_GetCurrentLineNumber(parser)) + ". Additional information: " + XML_ErrorString(XML_GetErrorCode(parser)), "ExpatParser::parseXMLFile"); } } while (!done); } catch(...) { XML_ParserFree(parser); throw; } XML_ParserFree(parser); }
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 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 XmlReader::Open() { #if defined(READER_SUPPORT_XML) stream = fopen(filename.c_str(), "r"); parser = XML_ParserCreate("UTF-8"); XML_SetUserData(parser, (void*) this); XML_SetElementHandler(parser, StartElementHandler, EndElementHandler); XML_SetCharacterDataHandler(parser, CharacterDataHandler); handlers.push_back(NULL); #endif }
/** * @function expat.parser * * ### Synopsis * * var parser = expat.parser(thisObj, startFn, endFn, textFn); * * Instantiate an XML parser. * * The thisObj argument is the value of "this" passed to startFn and endFn. * * The startFn function is called with an element name and attributes object when an open tag is encountered. * * The endFn function is called with an element name when a close tag is encountered. * * The textFn function is called with the value between the tags. * * ### Callback Signatures * * startFn(name, attr); // {string} name, {object} attr * endFn(name); // {string} name * textFn(text); // {string} text * * @param {object} thisObj - object to be passed as "this" to startFn, endFn, and textFn * @param {function} startFn - function to be called when a start tag is encountered during parsing. * @param {function} endFn - function to be called when an end tag is encountered during parsing. * @param {function} textFn - function to be called with the text (value) between start/end tags during parsing. * * @return {object} parser - opaque handle to an expat parser. */ static JSVAL parser(JSARGS args) { p *ptr = new p; ptr->thisObj = Persistent<Object>::New(args[0]->ToObject()); ptr->parser = XML_ParserCreate(NULL); XML_SetUserData(ptr->parser, (void *) ptr); XML_SetElementHandler(ptr->parser, start, end); XML_SetCharacterDataHandler(ptr->parser, charHandler); ptr->start = Persistent<Function>::New(Local<Function>::Cast(args[1])); ptr->end = Persistent<Function>::New(Local<Function>::Cast(args[2])); ptr->charHandler = Persistent<Function>::New(Local<Function>::Cast(args[3])); return Opaque::New(ptr); }
//---------------------- /////////////////////////////////////////////////////// // // ChercheLaTag() -- better to rewrite this!! // /////////////////////////////////////////////////////// void simpleXMLparser::CherchezLaTag() { XML_ParserReset(XMLp, NULL); XML_SetElementHandler(XMLp, simpleXMLparser::openingHndl, simpleXMLparser::closingHndl); XML_SetCharacterDataHandler(XMLp, simpleXMLparser::textHndl); XML_SetUserData(XMLp, this); FILE * inputFile; if ( ! (inputFile = fopen(xmlFileName,"r")) ) { std::cout << "Error: File \"" << xmlFileName << "\" does not exist\n" ; exit(-1); } searchTag=tXMLpathList.front(); // tag for search currentTagNumber=0; Depth = 0; prevDepth = 0; searchDepth= tXMLpathList.size(); currentAttr.clear(); returnAttr.clear(); ifStop=false; for (;;) { int done; int len; len = fread(Buff, 1, BUFFSIZE, inputFile); if (ferror(inputFile)) { std::cout << "\nError: read error\n\n"; exit(-1); } done = feof(inputFile); if (XML_Parse(XMLp, Buff, len, done) == XML_STATUS_ERROR) { std::cout << "\nError: parse error at line " << XML_GetCurrentLineNumber(XMLp) << ": " << XML_ErrorString(XML_GetErrorCode(XMLp)) << "\n\n"; exit(-1); } if (done) break; } fclose(inputFile); tXMLpathList.clear(); }
/** * 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; }
void xmlParseClientEvent (char *xml_string, int len, NOTICE *notice) { XML_Parser parser; CLIENT_PARSE_INFO *parse_info; parse_info = calloc (1, sizeof *parse_info); parser = XML_ParserCreate (NULL); if (!parser) { logMsg (DBG_GEN, "Couldn't create an XML parsing object: %s\n", (char *)XML_ErrorString (XML_GetErrorCode (parser) )); free (parse_info); return; } /* Set handlers */ XML_SetElementHandler (parser, xmlParseClientStart, xmlParseClientEnd); XML_SetCharacterDataHandler (parser, xmlParseClientChar); /* Set up data structures to pass */ if (parse_info) { parse_info->notice = notice; parse_info->parser = parser; parse_info->current_tag = NULL; } XML_SetUserData (parser, parse_info); /* Now parse our xml string buffer. Note that we supply a final arguement * of 1 which tells the parser that this is the last bit of xml data that * it's going to parse, which is true for this instantation */ if (! XML_Parse (parser, xml_string, len, 1) ) { logMsg (DBG_GEN, "Uh Oh! There was an XML parsing error: %s\n", (char *)XML_ErrorString ( XML_GetErrorCode (parser) )); /* Try to continue */ } XML_ParserFree (parser); if (parse_info && parse_info->current_tag) { free (parse_info->current_tag); } free (parse_info); }
void opml_process(gchar *path, OPMLProcessFunc function, gpointer data) { OPMLProcessCtx *ctx = NULL; gchar *contents = NULL; GError *error = NULL; gint status, err; /* Initialize our context */ ctx = malloc( sizeof(OPMLProcessCtx) ); ctx->parser = XML_ParserCreate(NULL); ctx->depth = 0; ctx->str = NULL; ctx->user_function = function; ctx->body_reached = FALSE; ctx->user_data = data; /* Set expat parser handlers */ XML_SetUserData(ctx->parser, (void *)ctx); XML_SetElementHandler(ctx->parser, _opml_parser_start, _opml_parser_end); XML_SetCharacterDataHandler(ctx->parser, libfeed_expat_chparse); XML_SetUnknownEncodingHandler(ctx->parser, feed_parser_unknown_encoding_handler, NULL); g_file_get_contents(path, &contents, NULL, &error); if( error || !contents ) return; /* lines = g_strsplit(contents, '\n', 0); while( lines[i] ) { status = XML_Parse(ctx->parser, lines[i], strlen(lines[i]), FALSE); if( status == XML_STATUS_ERROR ) { err = XML_GetErrorCode(ctx->parser); sprintf(stderr, "\nExpat: --- %s\n\n", XML_ErrorString(err)); } } */ status = XML_Parse(ctx->parser, contents, strlen(contents), FALSE); err = XML_GetErrorCode(ctx->parser); fprintf(stderr, "\nExpat: --- %s (%s)\n\n", XML_ErrorString(err), (status == XML_STATUS_OK ? "OK" : "NOT OK")); XML_Parse(ctx->parser, "", 0, TRUE); XML_ParserFree(ctx->parser); g_free(ctx); }
JSBool xmljs_parse(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { XMLCallback *cb; XML_Parser xml; JSString *str; JSBool ok; cb = (XMLCallback *)JS_GetPrivate(cx, obj); if (!cb) { JS_ReportError(cx, "XMLParser object has no parser!"); return JS_FALSE; } if (cb->preParse && !cb->preParse(cx, obj, argc, argv, rval)) return JS_FALSE; if (argc < 1) { *rval = JSVAL_TRUE; return JS_TRUE; } xml = XML_ParserCreate(NULL); if (!xml) return JS_FALSE; /* XXX report error */ /* after this point, have to leave via out: */ XML_SetElementHandler(xml, cb->start, cb->end); XML_SetCharacterDataHandler(xml, cb->cdata); XML_SetProcessingInstructionHandler(xml, cb->processing); XML_SetUserData(xml, (void *)cb); cb->xml = xml; str = JS_ValueToString(cx, argv[0]); if (!XML_Parse(xml, JS_GetStringBytes(str), JS_GetStringLength(str), 1)) { str = JS_NewStringCopyZ(cx, XML_ErrorString(XML_GetErrorCode(xml))); if (!str) { ok = JS_FALSE; goto out; } if (!JS_DefineProperty(cx, obj, "error", STRING_TO_JSVAL(str), NULL, NULL, JSPROP_ENUMERATE)) { ok = JS_FALSE; goto out; } *rval = JSVAL_FALSE; } else { *rval = JSVAL_TRUE; } out: XML_ParserFree(xml); cb->xml = NULL; return ok; }
int repo_add_appdata(Repo *repo, FILE *fp, int flags) { Pool *pool = repo->pool; struct parsedata pd; struct stateswitch *sw; Repodata *data; char buf[BUFF_SIZE]; int i, l; int ret = 0; data = repo_add_repodata(repo, flags); memset(&pd, 0, sizeof(pd)); pd.repo = repo; pd.pool = repo->pool; pd.data = data; pd.content = malloc(256); pd.acontent = 256; for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++) { if (!pd.swtab[sw->from]) pd.swtab[sw->from] = sw; pd.sbtab[sw->to] = sw->from; } XML_Parser 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_error(pool, -1, "repo_appdata: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser)); ret = -1; break; } if (l == 0) break; } XML_ParserFree(parser); if (!(flags & REPO_NO_INTERNALIZE)) repodata_internalize(data); free(pd.content); return ret; }
static void _run_character_check(XML_Char *text, XML_Char *expected, const char *file, int line) { CharData storage; CharData_Init(&storage); XML_SetUserData(parser, &storage); XML_SetCharacterDataHandler(parser, accumulate_characters); if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR) _xml_failure(parser, file, line); CharData_CheckXMLChars(&storage, expected); }