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; }
XMPPStanza* stanza_parse(char *stanza_text) { ParseState *state = malloc(sizeof(ParseState)); state->depth = 0; state->curr_stanza = NULL; XML_Parser parser = XML_ParserCreate(NULL); XML_SetElementHandler(parser, _start_element, _end_element); XML_SetCharacterDataHandler(parser, _handle_data); XML_SetUserData(parser, state); XML_Parse(parser, stanza_text, strlen(stanza_text), 0); XML_ParserFree(parser); return state->curr_stanza; }
int loadGameConfig(void) { char buf[BUFSIZ]; XML_Parser parser = XML_ParserCreate(NULL); int done, i, depth = 0; FILE *config = NULL; totalGames = 0; XML_SetUserData(parser, &depth); XML_SetElementHandler(parser, startElement, endElement); XML_SetCharacterDataHandler(parser, characterData); config = fopen("/boot/uboot/beaglesnes/games.xml", "r"); if (!config) { fprintf(stderr, "Unable to open game configuration file games.xml\n"); return 1; } /* Initialize the flags for tag in use and defined */ for (i = TAG_FIRST; i < TAG_LAST; i++) { inTagFlag[i] = 0; definedTagFlag[i] = 0; } /* Initialize the dummy head sentinel */ fprintf(stderr, "Creating sentinel\n"); gameInfo = (gameInfo_t *)calloc(1, sizeof(gameInfo_t)); currentGame = gameInfo; do { int len = (int)fread(buf, 1, sizeof(buf), config); done = len < sizeof(buf); if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) { fprintf(stderr, "%s at line %lu\n", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser)); fclose(config); return 1; } } while (!done); XML_ParserFree(parser); fclose(config); return 0; }
int main(int argc, char *argv[]) { int done; char buf[BUFSIZ]; FILE *infile, *outfile; XML_Parser parser = XML_ParserCreate(NULL); ESIS_Writer writer = ESIS_WriterCreate(stdout, 0U); if (argc == 2) { infile = fopen(argv[1], "r"); if (infile == NULL) { perror(argv[1]); return 1; } } else infile = stdin; outfile = stdout; XML_SetUserData(parser, writer); XML_SetElementHandler(parser, ESIS_Start, ESIS_End); XML_SetCharacterDataHandler(parser, (XML_CharacterDataHandler)ESIS_Cdata); do { size_t len = fread(buf, 1, sizeof(buf), infile); done = len < sizeof(buf); if (XML_Parse(parser, buf, (int)len, done) == 0) { fprintf(stderr, "%s at line %d\n", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser)); return 1; } } while (!done); XML_ParserFree(parser); ESIS_WriterFree(writer); return 0; }
/**************************************************************************************************************** * Parse configuration *****************************************************************************************************************/ NFcompModel_p NFmodelParse (FILE *inFile, bool report) { char *doc; NFdata_t data; XML_Parser parser; data.SkipName = "root"; data.Abort = false; data.Buffer = (char *) NULL; data.BufferLen = 0; data.Skip = false; data.Stack = data.StackSize = data.SkipLevel = 0; data.Model = (NFcompModel_p) NULL; data.Objects = (NFobject_p *) NULL; if ((doc = _NFreadDoc (inFile)) == (char *) NULL) { CMmsgPrint (CMmsgAppError, "Document reading error in %s:%d\n",__FILE__,__LINE__); return ((NFcompModel_p) NULL); } if ((parser = XML_ParserCreate(NULL)) == (XML_Parser) NULL) { CMmsgPrint (CMmsgSysError, "Memory allocation in %s:%d\n",__FILE__,__LINE__); return ((NFcompModel_p) NULL); } XML_SetUserData (parser, &data); XML_SetElementHandler (parser, _NFentryStart, _NFentryEnd); XML_SetCharacterDataHandler (parser, _NFentryText); XML_UseParserAsHandlerArg (parser); if (XML_Parse(parser, doc, strlen (doc), true) == XML_STATUS_ERROR) { CMmsgPrint (CMmsgAppError,"Parse error at line %d\n", XML_GetCurrentLineNumber(parser)); return ((NFcompModel_p) NULL); } XML_ParserFree (parser); if (data.Objects != (NFobject_p *) NULL) free (data.Objects); if ((data.Abort) && (data.Model != (NFcompModel_p) NULL)) { NFobjectFree ((NFobject_p) data.Model); return ((NFcompModel_p) NULL); } if (report) NFobjectPrint ((NFobject_p) (data.Model)); return (data.Model); }
void ExpatAdapter::ParseBuffer ( const void * buffer, size_t length, bool last /* = true */ ) { enum XML_Status status; if ( length == 0 ) { // Expat does not like empty buffers. if ( ! last ) return; buffer = kOneSpace; length = 1; } status = XML_Parse ( this->parser, (const char *)buffer, length, last ); #if BanAllEntityUsage if ( this->isAborted ) XMP_Throw ( "DOCTYPE is not allowed", kXMPErr_BadXML ); #endif if ( status != XML_STATUS_OK ) { XMP_StringPtr errMsg = "XML parsing failure"; #if 0 // XMP_DebugBuild // Disable for now to make test output uniform. Restore later with thread safety. // *** This is a good candidate for a callback error notification mechanism. // *** This code is not thread safe, the sExpatMessage isn't locked. But that's OK for debug usage. enum XML_Error expatErr = XML_GetErrorCode ( this->parser ); const char * expatMsg = XML_ErrorString ( expatErr ); int errLine = XML_GetCurrentLineNumber ( this->parser ); char msgBuffer[1000]; // AUDIT: Use of sizeof(msgBuffer) for snprintf length is safe. snprintf ( msgBuffer, sizeof(msgBuffer), "# Expat error %d at line %d, \"%s\"", expatErr, errLine, expatMsg ); sExpatMessage = msgBuffer; errMsg = sExpatMessage.c_str(); #if DumpXMLParseEvents if ( this->parseLog != 0 ) fprintf ( this->parseLog, "%s\n", errMsg, expatErr, errLine, expatMsg ); #endif #endif XMP_Throw ( errMsg, kXMPErr_BadXML ); } } // ExpatAdapter::ParseBuffer
static void parse_position(Eina_List **cache, const char *filename, const char *state_file) { dbg("Checking current position of %s", filename); int fd = open(state_file, O_RDONLY); if (fd == -1) return; XML_Parser parser = XML_ParserCreate(NULL); XML_SetStartElementHandler(parser, _start_element); _context_t ctx = { .cache = cache, .filename = NULL, .parser = parser }; XML_SetUserData(parser, &ctx); dbg("Parsing"); char buffer[4096]; for (;;) { int read_ = read(fd, buffer, 4096); dbg("Read %d bytes from state.xml: %.*s", read_, read_, buffer); if (read_ < 0) { dbg("Got error %s", strerror(errno)); if (errno == EINTR || errno == EAGAIN) continue; else break; } else { int res = XML_Parse(parser, buffer, read_, read_ == 0); dbg("Got %d (%d: %s, %d:%d) from XML_Parse", res, XML_GetErrorCode(parser), XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser), XML_GetCurrentColumnNumber(parser)); if (read_ == 0 || res == XML_STATUS_ERROR) break; } } close(fd); }
static void parseDTD(XML_Parser parser, const std::string &fileName) { XML_Parser entityParser = XML_ExternalEntityParserCreate(parser, 0, 0); ZLFile dtdFile(fileName); shared_ptr<ZLInputStream> entityStream = dtdFile.inputStream(); if (!entityStream.isNull() && entityStream->open()) { const size_t BUFSIZE = 2048; char buffer[BUFSIZE]; size_t length; do { length = entityStream->read(buffer, BUFSIZE); if (XML_Parse(entityParser, buffer, length, 0) == XML_STATUS_ERROR) { break; } } while (length == BUFSIZE); } XML_ParserFree(entityParser); }
static int expat_erl_control(ErlDrvData drv_data, unsigned int command, char *buf, int len, char **rbuf, int rlen) { expat_data* d = (expat_data*)drv_data; int res, errcode; char *errstring; ErlDrvBinary *b; size_t size; switch (command) { case PARSE_COMMAND: case PARSE_FINAL_COMMAND: ei_x_new_with_version(&event_buf); res = XML_Parse(d->parser, buf, len, command == PARSE_FINAL_COMMAND); if(!res) { errcode = XML_GetErrorCode(d->parser); errstring = (char *)XML_ErrorString(errcode); ei_x_encode_list_header(&event_buf, 1); ei_x_encode_tuple_header(&event_buf, 2); ei_x_encode_long(&event_buf, XML_ERROR); ei_x_encode_tuple_header(&event_buf, 2); ei_x_encode_long(&event_buf, errcode); ei_x_encode_string(&event_buf, errstring); } ei_x_encode_empty_list(&event_buf); size = event_buf.index; b = driver_alloc_binary(size); memcpy(b->orig_bytes, event_buf.buff, size); ei_x_free(&event_buf); *rbuf = (char *)b; return size; default: return 0; } }
bool CCSAXParser::parse(const char *pszFile) { bool bRet = false; char* buf = NULL; s3eFile* file = NULL; do { file = s3eFileOpen(pszFile, "r"); if (!file) { IwAssertMsg(GAME, file, ("Open file %s Failed. s3eFileError Code : %i", pszFile, s3eFileGetError())); break; } s3eFileSeek(file, 0, S3E_FILESEEK_END); int size = s3eFileTell(file); s3eFileSeek(file, 0, S3E_FILESEEK_SET); buf = new char[size]; int done =0; int len = (int)s3eFileRead(buf, 1, size, file); if (XML_Parse(s_pParser, buf, len, 1) == XML_STATUS_ERROR) { CCLog("GAME: cocos2d: plist err: %s at line %d", XML_ErrorString(XML_GetErrorCode(s_pParser)), XML_GetCurrentLineNumber(s_pParser)); break; } bRet = true; } while(0); // cleanup if (file) { s3eFileClose(file); } if (buf) { delete []buf; } return bRet; }
int xps_parse_metadata(xps_context_t *ctx, xps_part_t *part) { XML_Parser xp; int code; char buf[1024]; char *s; /* Save directory name part */ xps_strlcpy(buf, part->name, sizeof buf); s = strrchr(buf, '/'); if (s) s[0] = 0; /* _rels parts are voodoo: their URI references are from * the part they are associated with, not the actual _rels * part being parsed. */ s = strstr(buf, "/_rels"); if (s) *s = 0; ctx->base_uri = buf; ctx->part_uri = part->name; xp = XML_ParserCreate(NULL); if (!xp) return gs_throw(-1, "cannot create XML parser"); XML_SetUserData(xp, ctx); XML_SetParamEntityParsing(xp, XML_PARAM_ENTITY_PARSING_NEVER); XML_SetStartElementHandler(xp, (XML_StartElementHandler)xps_parse_metadata_imp); code = XML_Parse(xp, (char*)part->data, part->size, 1); XML_ParserFree(xp); ctx->base_uri = NULL; ctx->part_uri = NULL; if (code == 0) return gs_throw1(-1, "cannot parse XML in part: %s", part->name); return 0; }
int mb_kbd_config_load(MBKeyboard *kbd, char *variant) { char *data; XML_Parser p; MBKeyboardConfigState *state; if (!(data = load_config_file ("keyboard", variant, 1, &kbd->config_file))) util_fatal_error("Couldn't find a keyboard config file\n"); p = XML_ParserCreate(NULL); if (!p) util_fatal_error("Couldn't allocate memory for XML parser\n"); if (variant && !strstr(kbd->config_file, variant)) fprintf(stderr, "matchbox-keyboard: *Warning* Unable to locate variant: %s\n" " falling back to %s\n", variant, kbd->config_file); state = util_malloc0(sizeof(MBKeyboardConfigState)); state->keyboard = kbd; state->parser = p; XML_SetElementHandler(p, config_xml_start_cb, NULL); /* XML_SetCharacterDataHandler(p, chars); */ XML_SetUserData(p, (void *)state); if (! XML_Parse(p, data, strlen(data), 1)) { fprintf(stderr, "matchbox-keyboard:%s:%d: XML Parse error:%s\n", kbd->config_file, (int)XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p))); util_fatal_error("XML Parse failed.\n"); } XML_ParserFree (p); return 1; }
int main(int argc, char * argv[]) { char buf[BUFSIZ]; FILE *in; XML_Parser parser; if (!argv[1]) { in = stdin; } else if (!(in = fopen (argv[1], "r"))) { printf ("Unable to open input file %s\n", argv[1]); return (2); } /* Create the parser and set the input handlers. */ parser = XML_ParserCreate(NULL); XML_SetElementHandler (parser, startElement, endElement); XML_SetCharacterDataHandler (parser, charData); vot = (VOTable *) newType (TY_VOTABLE); do { size_t len = fread (buf, 1, sizeof(buf), in); done = len < sizeof(buf); if (!XML_Parse (parser, buf, len, done)) { fprintf (stderr, "Error: %s at line %d\n", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser)); return (1); } } while (!done); XML_ParserFree(parser); if (in != stdin) fclose (in); free ((void *)vot); return (0); }
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; }
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; }
BrokerMessage *sb_parser_process(XML_Parser p, char *buffer, int len) { BrokerParserData *bp = (BrokerParserData *) XML_GetUserData(p); bp->msg = calloc(1, sizeof(BrokerMessage)); XML_ParserReset(p, NULL); XML_SetUserData(p, bp); XML_SetElementHandler(p, sbx_start, sbx_end); XML_SetCharacterDataHandler(p, getText); if (!XML_Parse(p, buffer, len, 1)) { fprintf(stderr, "Parse error at line %d:\n%s\n", XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p))); exit(-1); } return bp->msg; }
END_TEST /* Regression test for SF bug #824420. Checks that an xmlns:prefix attribute set in an attribute's default value isn't misinterpreted. */ START_TEST(test_ns_in_attribute_default_without_namespaces) { char *text = "<!DOCTYPE e:element [\n" " <!ATTLIST e:element\n" " xmlns:e CDATA 'http://example.com/'>\n" " ]>\n" "<e:element/>"; if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR) xml_failure(parser); }
END_TEST /* See related SF bug #673791. When namespace processing is enabled, setting the namespace URI for a prefix is not allowed; this test ensures that it *is* allowed when namespace processing is not enabled. (See Namespaces in XML, section 2.) */ START_TEST(test_empty_ns_without_namespaces) { char *text = "<doc xmlns:prefix='http://www.example.com/'>\n" " <e xmlns:prefix=''/>\n" "</doc>"; if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR) xml_failure(parser); }
END_TEST START_TEST(test_utf16) { /* <?xml version="1.0" encoding="UTF-16"?> <doc a='123'>some text</doc> */ char text[] = "\000<\000?\000x\000m\000\154\000 \000v\000e\000r\000s\000i\000o" "\000n\000=\000'\0001\000.\000\060\000'\000 \000e\000n\000c\000o" "\000d\000i\000n\000g\000=\000'\000U\000T\000F\000-\0001\000\066" "\000'\000?\000>\000\n" "\000<\000d\000o\000c\000 \000a\000=\000'\0001\0002\0003\000'" "\000>\000s\000o\000m\000e\000 \000t\000e\000x\000t\000<\000/" "\000d\000o\000c\000>"; if (XML_Parse(parser, text, sizeof(text)-1, XML_TRUE) == XML_STATUS_ERROR) xml_failure(parser); }
CXmlDocument& CXmlLoader::Load(CXmlDocument & doc){ bool done; m_ctx.root = m_ctx.node = NULL; do { size_t len = GetIOHandler().LoadBuffer(m_buf, BUFSIZE); done = (len < BUFSIZE); if (!XML_Parse(m_parser, m_buf, len, done)) { CXmlLoadException ex(XML_ErrorString(XML_GetErrorCode(m_parser)), XML_GetErrorCode(m_parser), XML_GetCurrentLineNumber(m_parser)); throw ex; } } while (!done); doc.SetRoot(m_ctx.root); return doc; };
END_TEST /* Regression test #2 for SF bug #653180. */ START_TEST(test_column_number_after_parse) { char *text = "<tag></tag>"; XML_Size colno; if (XML_Parse(parser, text, strlen(text), XML_FALSE) == XML_STATUS_ERROR) xml_failure(parser); colno = XML_GetCurrentColumnNumber(parser); if (colno != 11) { char buffer[100]; sprintf(buffer, "expected 11 columns, saw %" XML_FMT_INT_MOD "u", colno); fail(buffer); } }
//-------------------------------------------------------------------- bool ExpatSaxParser::parseBuffer(const char* uri, const char* buffer, int length) { mParser = XML_ParserCreate(0); XML_SetUserData(mParser, this); XML_SetElementHandler(mParser, startElement, endElement); XML_SetCharacterDataHandler(mParser, characters); XML_Status status = XML_STATUS_OK; bool isFinal = true; XML_Parse(mParser, buffer, (int)length, isFinal); XML_ParserFree(mParser); return status != XML_STATUS_ERROR; }
static size_t parseStreamCallback(void *contents, size_t length, size_t nmemb, void *userp) { XML_Parser parser = (XML_Parser) userp; size_t real_size = length * nmemb; struct ParserStruct *state = (struct ParserStruct *) XML_GetUserData(parser); /* Only parse if we're not already in a failure state. */ if(state->ok && XML_Parse(parser, contents, real_size, 0) == 0) { int error_code = XML_GetErrorCode(parser); fprintf(stderr, "Parsing response buffer of length %lu failed" " with error code %d (%s).\n", real_size, error_code, XML_ErrorString(error_code)); state->ok = 0; } return real_size; }
BOOLEAN ReadInSoundArray(STR fileName) { HWFILE hFile; UINT32 uiBytesRead; UINT32 uiFSize; CHAR8 * lpcBuffer; XML_Parser parser = XML_ParserCreate(NULL); soundParseData pData; DebugMsg(TOPIC_JA2, DBG_LEVEL_3, String("Loading %s",SOUNDSFILENAME ) ); // Open sounds 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, soundStartElementHandle, soundEndElementHandle); XML_SetCharacterDataHandler(parser, soundCharacterDataHandle); memset(&pData,0,sizeof(pData)); pData.maxArraySize = MAX_SAMPLES; pData.curIndex = -1; XML_SetUserData(parser, &pData); if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE)) { CHAR8 errorBuf[511]; sprintf(errorBuf, "XML Parser Error in %s.xml: %s at line %d", SOUNDSFILENAME, XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser)); LiveMessage(errorBuf); MemFree(lpcBuffer); return FALSE; } MemFree(lpcBuffer); XML_ParserFree(parser); return( TRUE ); }
//XmlNodeRef XmlParserImp::parse( const std::vector<char> &buffer,String &errorString ) XmlNodeRef XmlParserImp::parse( const char * buffer, int buffersize,String &errorString ) { m_parser = XML_ParserCreate(NULL); XML_SetUserData( m_parser, this ); XML_SetElementHandler( m_parser, startElement,endElement ); XML_SetCharacterDataHandler( m_parser,characterData ); XmlNodeRef root = 0; /* int size = file->size(); char *buf = (char*)memory::malloc( size ); file->read( buf,size ); if (!XML_Parse( parser,buf,size,1 )) { error( "XML Error (%s): %s at line %d\n",filename.c_str(),XML_ErrorString(XML_GetErrorCode(parser)),XML_GetCurrentLineNumber(parser) ); return false; } memory::free( buf ); XMLParser::parse( fileName ); */ // if (XML_Parse( m_parser,buffer,buffer.size(),1 )) if (XML_Parse( m_parser,buffer,buffersize,1 )) { root = m_root; } else { char str[32768]; #if _MSC_VER<=1200 sprintf( str,"XML Error: %s at line %d",XML_ErrorString(XML_GetErrorCode(m_parser)),XML_GetCurrentLineNumber(m_parser) ); #else sprintf_s( str,sizeof(str),"XML Error: %s at line %d",XML_ErrorString(XML_GetErrorCode(m_parser)),XML_GetCurrentLineNumber(m_parser) ); #endif errorString = str; } XML_ParserFree( m_parser ); m_root = 0; return root; }
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 }
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)); XML_ParserFree(parser); if (pd->solvable) { repo_free_solvable(pd->repo, pd->solvable - pd->pool->solvables, 1); pd->solvable = 0; } return; } if (l == 0) break; } XML_ParserFree(parser); }
Appcast Appcast::Load(const std::string& xml) { 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(), is_suitable_windows_item); if (it != ctxt.items.end()) return *it; else { it = std::find_if(ctxt.items.begin(), ctxt.items.end(), is_windows_version_acceptable); if (it != ctxt.items.end()) return *it; else return Appcast(); // There are no items that meet the set minimum os version } }
int main(int argc, char **argv) { if (argc != 3) { fprintf(stderr, "Usage: %s formname,filename\n", argv[0]); return (1); } char *form_name=argv[1]; FILE *f=fopen(argv[2],"r"); XML_Parser parser; size_t size; char *xmltext; //ParserCreation parser = XML_ParserCreate(NULL); if (parser == NULL) { fprintf(stderr, "Parser not created\n"); return (1); } // Tell expat to use functions start() and end() each times it encounters the start or end of an element. XML_SetElementHandler(parser, start, end); XML_SetCharacterDataHandler(parser, characterdata); XML_SetUserData(parser, form_name); //Open XML File xmltext = malloc(MAXCHARS); size = fread(xmltext, sizeof(char), MAXCHARS, f); //Parse Xml Text if (XML_Parse(parser, xmltext, strlen(xmltext), XML_TRUE) == XML_STATUS_ERROR) { fprintf(stderr, "Cannot parse , file may be too large or not well-formed XML\n"); return (1); } //Close fclose(f); XML_ParserFree(parser); fprintf(stdout, "Successfully parsed %i characters !\n", size); return (0); }
SkXMLPullParser::EventType SkXMLPullParser::onNextToken() { if (Data::RETURN_END_TAG == fImpl->fData.fState) { fImpl->fData.fState = Data::NORMAL; fCurr.fName = fImpl->fData.fEndTag; // restore name from (below) save return SkXMLPullParser::END_TAG; } fImpl->fData.fAlloc.reuse(); XML_Parser p = fImpl->fData.fParser; XML_Status status; status = XML_ResumeParser(p); CHECK_STATUS: switch (status) { case XML_STATUS_OK: return SkXMLPullParser::END_DOCUMENT; case XML_STATUS_ERROR: if (XML_GetErrorCode(p) != XML_ERROR_NOT_SUSPENDED) { reportError(p); return SkXMLPullParser::ERROR; } status = XML_Parse(p, (const char*)fImpl->fBuffer, fImpl->fBufferLen, true); goto CHECK_STATUS; case XML_STATUS_SUSPENDED: if (Data::MISSED_START_TAG == fImpl->fData.fState) { // return a start_tag, and clear the flag so we return end_tag next SkASSERT(SkXMLPullParser::END_TAG == fCurr.fEventType); fImpl->fData.fState = Data::RETURN_END_TAG; fImpl->fData.fEndTag = fCurr.fName; // save this pointer return SkXMLPullParser::START_TAG; } break; } return fCurr.fEventType; }