int htmllex() { #ifdef HAVE_EXPAT static char *begin_html = "<HTML>"; static char *end_html = "</HTML>"; char *s; char *endp = 0; int len, llen; int rv; state.tok = 0; do { if (state.mode == 2) return EOF; if (state.mode == 0) { state.mode = 1; s = begin_html; len = strlen(s); endp = 0; } else { s = state.ptr; if (*s == '\0') { state.mode = 2; s = end_html; len = strlen(s); } else { endp = findNext(s,&state.lb); len = endp - s; } } state.prevtok = state.currtok; state.prevtoklen = state.currtoklen; state.currtok = s; state.currtoklen = len; if ((llen = agxblen(&state.lb))) rv = XML_Parse(state.parser, agxbuse(&state.lb),llen, 0); else rv = XML_Parse(state.parser, s, len, (len ? 0 : 1)); if (rv == XML_STATUS_ERROR) { if (!state.error) { agerr(AGERR, "%s in line %d \n", XML_ErrorString(XML_GetErrorCode(state.parser)), htmllineno()); error_context(); state.error = 1; state.tok = T_error; } } if (endp) state.ptr = endp; } while (state.tok == 0); #if DEBUG printTok (state.tok); #endif return state.tok; #else return EOF; #endif }
int main(int argc, char *argv[]) { XML_Parser p = XML_ParserCreate(NULL); int done = 0, len; if (!p) { fprintf(stderr, "Couldn't allocate memory for parser\n"); exit(-1); }//if if (argv[1]) FreqThreshold = atof(argv[1]) / 100; XML_SetElementHandler(p, start, end); while (!done) { len = fread(Buff, 1, BUFFSIZE, stdin); if (ferror(stdin)) { fprintf(stderr, "Read error\n"); return -1; }//if done = feof(stdin); if (XML_Parse(p, Buff, len, done) == XML_STATUS_ERROR) { fprintf(stderr, "Parse error at line %d:\n%s\n", (int)XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p))); return -1; }//if }//while return 0; }//main
rhcs_clustat *parse_rhcs_clustat(FILE *in) { char *buf; size_t len; int done = 0; XML_Parser parser; rhcs_clustat *clustat; nodes = 0; services = 0; clustat = mp_calloc(1, sizeof(rhcs_clustat)); // Create Parser parser = XML_ParserCreate(NULL); XML_SetUserData(parser, clustat); XML_SetElementHandler(parser, rhcs_clustat_startElement, rhcs_clustat_stopElement); buf = mp_calloc(BUFFERSIZE, 1); do { len = fread(buf, 1, BUFFERSIZE, in); if (!XML_Parse(parser, buf, len, done)) { fprintf(stderr, "%s at line %d\n", XML_ErrorString(XML_GetErrorCode(parser)), (int) XML_GetCurrentLineNumber(parser)); return NULL; } } while (len == BUFFERSIZE && done == 0); XML_ParserFree(parser); return clustat; }
int build_sampl_pkts_from_xml (GW_SCRIPT_PKT_T * pkts, int max_pkts, char *xml_buf, int size) { char c; int i; XML_Parser p; pb_state = WAIT_STATE; pb_cnt = 0; pb_gw_pkt = pkts; pb_gw_pkt_max = max_pkts; //Creates an instance of the XML Parser to parse the event packet p = XML_ParserCreate (NULL); if (!p) { log_write ("Couldnt allocate memory for XML Parser\n"); return -1; } //Sets the handlers to call when parsing the start and end of an XML element XML_SetElementHandler (p, startElement, endElement); // XML_SetCharacterDataHandler (p, charData); if (XML_Parse (p, xml_buf, size, 1) == XML_STATUS_ERROR) { sprintf (global_error_msg, "XML config file parse error at line %u: %s\n", XML_GetCurrentLineNumber (p), XML_ErrorString (XML_GetErrorCode (p))); log_write (global_error_msg); XML_ParserFree (p); return -1; } XML_ParserFree (p); return pb_cnt; }
int main(int argc, char *argv[]) { char buf[BUFSIZ]; XML_Parser parser = XML_ParserCreate(NULL); int done; int depth = 0; (void)argc; (void)argv; XML_SetUserData(parser, &depth); XML_SetElementHandler(parser, startElement, endElement); do { size_t len = fread(buf, 1, sizeof(buf), stdin); done = len < sizeof(buf); if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) { fprintf(stderr, "%s at line %" XML_FMT_INT_MOD "u\n", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser)); return 1; } } while (!done); XML_ParserFree(parser); return 0; }
/* * Function * xmlReadFile * * Description * Read a config file * * Parameters * file name of the config file * * Return * root of the tree * NULL error. * * Remarks * */ txmlElement * xmlReadFile(const char *file) { FILE *in; char buf[BUFSIZ]; XML_Parser parser; int done; txmlElement *retElt; if ((in = fopen(file, "r")) == NULL) { fprintf(stderr, "xmlReadFile: file %s has pb (access rights ?)\n", file); return (txmlElement*)NULL; } parser = XML_ParserCreate((XML_Char*)NULL); XML_SetUserData(parser, &retElt); XML_SetElementHandler(parser, startElement, endElement); XML_SetCharacterDataHandler(parser, CharacterData); do { size_t len = fread(buf, 1, sizeof(buf), in); done = len < sizeof(buf); if (!XML_Parse(parser, buf, len, done)) { fprintf(stderr, "file: %s -> %s at line %d\n", file, XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser)); return (txmlElement*)NULL; } } while (!done); XML_ParserFree(parser); return retElt; }
int main() { myParser parser; char filename[80]; FILE* xmlFile; for (;;) { int depth = 0; puts("\n\nXML test: enter filename"); gets(filename); if (strlen(filename)==0) break; xmlFile = fopen(filename, "r"); if (!xmlFile) break; if (!parser.parseFile(xmlFile)) { fprintf(stderr, "%s at line %d\n", XML_ErrorString(parser.XML_GetErrorCode()), parser.XML_GetCurrentLineNumber() ); return 1; } } // loop asking for and parsing files puts("\nfinished!"); }
int GameList::Load(const char *filename) { char buf[1024]; FILE *f; // Clear first Clear(); // Parse XML f = fopen(filename, "rb"); if( f == NULL ) { fprintf(stderr, "Unable to open XML file\n"); }else{ XML_Parser parser = XML_ParserCreate(NULL); int done; XML_SetUserData(parser, this); XML_SetElementHandler(parser, startElement, endElement); XML_SetCharacterDataHandler(parser, dataHandler); do { unsigned len = (int)fread(buf, 1, sizeof(buf), f); 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)); break; } } while (!done); XML_ParserFree(parser); fclose(f); } return elements; }
struct cmd_result *parse_command(char * buf,struct cmd_result *(*treat_func)(),void *sdata) { //allocate the command structure to fill with data from xml struct cmd *toparse=malloc(sizeof(struct cmd)); toparse->name=malloc(1024*sizeof(char)); bzero(toparse->name,1024); toparse->nb_params=0; toparse->params=malloc(MAX_PARAMS*sizeof(char *)); memset(toparse->params,0,MAX_PARAMS*sizeof(char*)); struct cmd_result *result; XML_Parser parser = XML_ParserCreate(NULL); XML_SetUserData(parser,toparse); XML_SetElementHandler(parser,cmd_handler_start,cmd_handler_end); XML_SetCharacterDataHandler(parser,cmd_handler_data); if (!XML_Parse(parser,buf,strlen(buf),1)) { printf("error in command XML_Parse : error=%d\n",XML_GetErrorCode(parser)); printf("%s\n",XML_ErrorString(XML_GetErrorCode(parser))); printf("buffer=%s\n",buf); result=malloc(sizeof(struct cmd_result)); result->retcode=0; result->str=NULL; } else { result=treat_func(toparse,sdata); } free_cmd(toparse); XML_ParserFree(parser); if (result->str==NULL) result->str=strdup("Malformed command"); return result; }
int xml_main(int argc, const char *argv) { char *buf = NULL; int depth = 0; if (argv == NULL){ printf("no element parse\n"); return 1; } XML_Parser parser = XML_ParserCreate(NULL); if (parser){ XML_SetUserData(parser, &depth); XML_SetElementHandler(parser, startElement, endElement); buf = (char*)malloc(argc + 1); bzero(buf, argc + 1); memcpy(buf, argv, argc); if (XML_Parse(parser, buf, argc, 0) == XML_STATUS_ERROR) { printf( "%s at line %" XML_FMT_INT_MOD "u\n", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser)); }else{ printf("XML_Parse Sucessful\n "); } } XML_ParserFree(parser); return 0; }
bool HippoGridInfo::retrieveGridInfo() { if (mLoginUri == "") return false; // If last character in uri is not "/" std::string uri = mLoginUri; if (uri.compare(uri.length()-1, 1, "/") != 0) { uri += '/'; } std::string reply; int result = HippoRestRequest::getBlocking(uri + "get_grid_info", &reply); if (result != 200) return false; llinfos << "Received: " << reply << llendl; bool success = true; XML_Parser parser = XML_ParserCreate(0); XML_SetUserData(parser, this); XML_SetElementHandler(parser, onXmlElementStart, onXmlElementEnd); XML_SetCharacterDataHandler(parser, onXmlCharacterData); mXmlState = XML_VOID; if (!XML_Parse(parser, reply.data(), reply.size(), TRUE)) { llwarns << "XML Parse Error: " << XML_ErrorString(XML_GetErrorCode(parser)) << llendl; success = false; } XML_ParserFree(parser); return success; }
void XML_Parser::raise(const char* format, ...) { if (_rep->error) return; _rep->error = true; XML_Error code = XML_GetErrorCode(_rep->parser); int line = XML_GetCurrentLineNumber(_rep->parser); Buffer buffer; if (code) buffer.format("line %d: %s: ", line, XML_ErrorString(code)); else buffer.format("line %d: error: ", line); va_list ap; va_start(ap, format); buffer.vformat(format, ap); va_end(ap); _rep->error_msg = buffer.data(); XML_StopParser(_rep->parser, XML_FALSE); }
/* -------------------------------------------------------- * this function "umount" a awareness protocol message and * returns a tree with the message information. * * Parameters : * AwString message : the awareness protocol message * Return : * AwTree * : the tree with awareness protocol message * information. * (NULL if an allocation problem occurs) * Note : * Even when a parser error occurs, a tree with the * information already parsed is returned. * -------------------------------------------------------- */ extern AwTree *AwParser_umountMessage (AwString message) { AwTree *tree = NULL; XML_Parser parser; char *input; tree = AwTree_new (); if (tree != NULL) { #ifdef DEBUG fprintf (stderr,"Creating XML parser for %s \n",(char *) message); #endif parser = XML_ParserCreate(NULL); XML_SetUserData(parser, tree); XML_SetElementHandler(parser, AwParser_startElement, AwParser_endElement); XML_SetCharacterDataHandler(parser,AwParser_textElement); input = AwString_get (message); /*do {*/ if (!XML_Parse(parser, input, strlen(input), 0 )) { fprintf(stderr, "%s at line %d\n", \ XML_ErrorString(XML_GetErrorCode(parser)), \ XML_GetCurrentLineNumber(parser)); } /*while ();*/ #ifdef DEBUG fprintf (stderr,"Message parsed\n"); #endif XML_ParserFree(parser); AW_FREE(input); } return tree; }
bool Xml::Parse(const wxFileName& filename) { Xml::filename = filename; XML_Parser parser = XML_ParserCreate(0); XML_SetElementHandler(parser, processStartTag, processEndTag); XML_SetCharacterDataHandler(parser, processData); FILE* xml = fopen(filename.GetFullPath(), "r"); if (!xml) return false; char buffer[1024]; int done; do { fgets(buffer, sizeof(buffer), xml); done = feof(xml); if (!done && XML_Parse(parser, buffer, strlen(buffer), 0) == XML_STATUS_ERROR) wxGetApp().Errorf("XML parse error at line %d:\n%s\n", XML_GetCurrentLineNumber(parser), XML_ErrorString(XML_GetErrorCode(parser))); } while (!done); fclose(xml); XML_ParserFree(parser); return true; }
void ParseXML::parseXML() { parser = XML_ParserCreate(NULL); if (!parser) { throw string("Couldn't allocate memory for parser"); } XML_SetUserData(parser, this); XML_SetElementHandler(parser, wrapper4Start, wrapper4End); XML_SetCharacterDataHandler(parser, wrapper4Chars); std::fstream in; in.open(filename.c_str(), std::ios::in); if (!in) { throw string("Cannot open xml file: ")+filename; } int length = 0; in.getline(buff, BUFSIZE); while ( true ) { if (! XML_Parse(parser, buff, strlen(buff), length)) { std::cout << "Parse error at line " << XML_GetCurrentLineNumber(parser) << XML_ErrorString(XML_GetErrorCode(parser)) << std::endl; throw string("Couldn't parse file: ") + filename; } if ( in.eof() ) break; else in.getline(buff, BUFSIZE); } }
static ERL_NIF_TERM parse(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { XML_Parser **parser; int is_final, res, errcode; ErlNifBinary stream; char *errstring; assert(argc == 3); if (!enif_get_resource(env, argv[0], PARSER_POINTER, (void **)&parser)) return enif_make_badarg(env); if (!enif_is_binary(env, argv[1])) return enif_make_badarg(env); enif_get_int(env, argv[2], &is_final); enif_inspect_binary(env, argv[1], &stream); expat_parser *parser_data = XML_GetUserData((XML_Parser)(*parser)); parser_data->result = enif_make_list(env, 0); parser_data->env = env; XML_SetUserData((XML_Parser)(*parser), parser_data); res = XML_Parse((XML_Parser)(*parser), (const char *)stream.data, stream.size, is_final); if(!res) { errcode = XML_GetErrorCode((XML_Parser)(*parser)); errstring = (char *)XML_ErrorString(errcode); return enif_make_tuple(env, 2, ERROR, enif_make_string(env, errstring, ERL_NIF_LATIN1)); } return enif_make_tuple(env, 2, OK, parser_data->result); };
BOOLEAN ReadInFoodOpinionStats(STR fileName) { HWFILE hFile; UINT32 uiBytesRead; UINT32 uiFSize; CHAR8 * lpcBuffer; XML_Parser parser = XML_ParserCreate(NULL); foodopinionParseData pData; DebugMsg(TOPIC_JA2, DBG_LEVEL_3, "Loading FoodOpinion.xml" ); // Open file hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE ); // if the file does not exist, exit // Flugente: no need to quit the game if the xml does not exist - this data just won't be there, but the game will still work if ( !hFile ) return( TRUE ); 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, foodopinionStartElementHandle, foodopinionEndElementHandle); XML_SetCharacterDataHandler(parser, foodopinionCharacterDataHandle); memset(&pData,0,sizeof(pData)); pData.curArray = FoodOpinions; pData.maxArraySize = NUM_PROFILES; XML_SetUserData(parser, &pData); if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE)) { CHAR8 errorBuf[511]; sprintf(errorBuf, "XML Parser Error in FoodOpinion.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 ); }
static void buildMenu(void) { /* XML parsing is done using expat */ int done = 1; int len = strlen(crut_api.menuBuffer); 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); if (! XML_Parse(p, crut_api.menuBuffer, len, done)) { crError("Parse error at line %d:\n%s\n", XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p))); } buildGLUTMenu( crut_server.stack ); buildValueArray(); }
void ExpatParser::parseXML(XMLHandler& handler, const RawDataContainer& source, const String& /*schemaName*/, bool /*allowXmlValidation*/) { // All stuff goes here XML_Parser parser = XML_ParserCreate(0); // Create a parser if (!parser) { CEGUI_THROW(GenericException("Unable to create a new Expat Parser")); } XML_SetUserData(parser, (void*)&handler); // Initialise user data XML_SetElementHandler(parser, startElement, endElement); // Register callback for elements XML_SetCharacterDataHandler(parser, characterData); // Register callback for character data // Parse the data (note that the last true parameter tels Expat that this is the last chunk of the document if (!XML_Parse(parser, reinterpret_cast<const char*>(source.getDataPtr()), source.getSize(), true)) { String exception (String((const encoded_char*)"XML Parsing error '") + String((const encoded_char*)XML_ErrorString(XML_GetErrorCode(parser))) + String((const encoded_char*)"' at line ") + PropertyHelper<uint>::toString(XML_GetCurrentLineNumber(parser))); // (We know it is a valid pointer, otherwise an exception would have been thrown above.) XML_ParserFree(parser); CEGUI_THROW(GenericException(exception)); } // (We know it is a valid pointer, otherwise an exception would have been thrown above.) XML_ParserFree(parser); }
void main(int argc, char **argv) { p = XML_ParserCreate(NULL); if (! p) { fprintf(stderr, "Couldn't allocate memory for parser\n"); exit(-1); } XML_SetElementHandler(p, start, end); for (;;) { int done; int len; len = fread(Buff, 1, BUFFSIZE, stdin); if (ferror(stdin)) { fprintf(stderr, "Read error\n"); exit(-1); } done = feof(stdin); if (! XML_Parse(p, Buff, len, done)) { fprintf(stderr, "Parse error at line %d:\n%s\n", XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p))); exit(-1); } if (done) break; } } /* End of main */
xml_data_node *xml_string_read(const char *string, xml_parse_options *opts) { xml_parse_info parse_info; int length = (int)strlen(string); /* set up the parser */ if (!expat_setup_parser(&parse_info, opts)) return NULL; /* parse the data */ if (XML_Parse(parse_info.parser, string, length, TRUE) == XML_STATUS_ERROR) { if (opts != NULL && opts->error != NULL) { opts->error->error_message = XML_ErrorString(XML_GetErrorCode(parse_info.parser)); opts->error->error_line = XML_GetCurrentLineNumber(parse_info.parser); opts->error->error_column = XML_GetCurrentColumnNumber(parse_info.parser); } xml_file_free(parse_info.rootnode); XML_ParserFree(parse_info.parser); return NULL; } /* free the parser */ XML_ParserFree(parse_info.parser); /* return the root node */ return parse_info.rootnode; }
result_t XmlParser::parse(XmlDocument *doc, exlib::string source) { XmlParser parser(doc, true); parser.m_now = doc; parser.m_list.push_back(doc); XML_Parser xml_parser = XML_ParserCreate(NULL); XML_SetParamEntityParsing(xml_parser, XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE); XML_SetUserData(xml_parser, &parser); XML_SetXmlDeclHandler(xml_parser, XmlDeclHandler); XML_SetElementHandler(xml_parser, StartElementHandler, EndElementHandler); XML_SetCharacterDataHandler(xml_parser, CharacterDataHandler); XML_SetProcessingInstructionHandler(xml_parser, ProcessingInstructionHandler); XML_SetCommentHandler(xml_parser, CommentHandler); XML_SetCdataSectionHandler(xml_parser, StartCdataSectionHandler, EndCdataSectionHandler); XML_SetStartDoctypeDeclHandler(xml_parser, StartDoctypeDeclHandler); if (XML_Parse(xml_parser, source.c_str(), (int32_t)source.length(), true) != XML_STATUS_OK) { char msg[128]; sprintf(msg, "XmlParser: error on line %lu at colum %lu: %s", XML_GetCurrentLineNumber(xml_parser), XML_GetCurrentColumnNumber(xml_parser) + 1, XML_ErrorString(XML_GetErrorCode(xml_parser))); XML_ParserFree(xml_parser); return CHECK_ERROR(Runtime::setError(msg)); } XML_ParserFree(xml_parser); return 0; }
xml_data_node *xml_data_node::string_read(const char *string, xml_parse_options const *opts) { xml_parse_info info; int length = (int)strlen(string); /* set up the parser */ if (!expat_setup_parser(info, opts)) return nullptr; /* parse the data */ if (XML_Parse(info.parser, string, length, 1) == XML_STATUS_ERROR) { if (opts != nullptr && opts->error != nullptr) { opts->error->error_message = XML_ErrorString(XML_GetErrorCode(info.parser)); opts->error->error_line = XML_GetCurrentLineNumber(info.parser); opts->error->error_column = XML_GetCurrentColumnNumber(info.parser); } info.rootnode->file_free(); XML_ParserFree(info.parser); return nullptr; } /* free the parser */ XML_ParserFree(info.parser); /* return the root node */ return info.rootnode; }
int gcode_svg_import (gcode_t *gcode, gcode_block_t *sketch_block, char * filename) { gcode_svg_t svg; XML_Parser p = XML_ParserCreate ("US-ASCII"); FILE *fh; int len; char *buffer; svg.gcode = gcode; svg.sketch_block = sketch_block; svg.width = 0.0; svg.height = 0.0; if(!p) { #if DEBUG fprintf (stderr, "Couldn't create parser for SVG!"); #endif return (1); } XML_SetElementHandler (p, svg_start, svg_end); XML_SetUserData (p, (void *) &svg); fh = fopen(filename, "r"); if (!fh) { #if DEBUG fprintf (stderr, "Couldn't load file: %s\n", filename); #endif XML_ParserFree (p); return (1); } fseek (fh, 0, SEEK_END); len = ftell (fh); buffer = (char *) malloc (len); fseek (fh, 0, SEEK_SET); fread (buffer, len, 1, fh); //File read, create sketch if (XML_Parse (p, buffer, len, 1) == XML_STATUS_ERROR) { #if DEBUG fprintf (stderr, "Parse error at line %d:\n%s\n", XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p))); #endif return (1); } fclose (fh); free (buffer); XML_ParserFree (p); svg.gcode->material_size[0] = svg.width * SCALEFACTOR; svg.gcode->material_size[1] = svg.height * SCALEFACTOR; gcode_prep (svg.gcode); }
void KML::parse() { std::size_t nDone = 0; std::size_t nLen = 0; char aBuf[BUFSIZ] = { 0 }; if( NULL == pKMLFile_ ) { sError_ = "No file given"; return; } if(poTrunk_ != NULL) { delete poTrunk_; poTrunk_ = NULL; } if(poCurrent_ != NULL) { delete poCurrent_; poCurrent_ = NULL; } XML_Parser oParser = OGRCreateExpatXMLParser(); XML_SetUserData(oParser, this); XML_SetElementHandler(oParser, startElement, endElement); XML_SetCharacterDataHandler(oParser, dataHandler); oCurrentParser = oParser; nWithoutEventCounter = 0; do { nDataHandlerCounter = 0; nLen = (int)VSIFReadL( aBuf, 1, sizeof(aBuf), pKMLFile_ ); nDone = VSIFEofL(pKMLFile_); if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR) { CPLError(CE_Failure, CPLE_AppDefined, "XML parsing of KML file failed : %s at line %d, column %d", XML_ErrorString(XML_GetErrorCode(oParser)), (int)XML_GetCurrentLineNumber(oParser), (int)XML_GetCurrentColumnNumber(oParser)); XML_ParserFree(oParser); VSIRewindL(pKMLFile_); return; } nWithoutEventCounter ++; } while (!nDone && nLen > 0 && nWithoutEventCounter < 10); XML_ParserFree(oParser); VSIRewindL(pKMLFile_); poCurrent_ = NULL; if (nWithoutEventCounter == 10) { CPLError(CE_Failure, CPLE_AppDefined, "Too much data inside one element. File probably corrupted"); } }
static void reportError(XML_Parser parser) { XML_Error code = XML_GetErrorCode(parser); int lineNumber = XML_GetCurrentLineNumber(parser); const char* msg = XML_ErrorString(code); printf("-------- XML error [%d] on line %d, %s\n", code, lineNumber, msg); }
/* * Proxy:parse() * * upvalue 1: Method * upvalue 2: Signal * * argument 1: proxy * argument 2: xml string */ EXPORT int proxy_parse(lua_State *L) { XML_Parser p; struct parsedata data; const char *xml; /* drop extra arguments */ lua_settop(L, 2); /* get the xml string */ xml = luaL_checkstring(L, 2); /* put the object name on the stack */ lua_getfield(L, 1, "object"); if (lua_isnil(L, 3)) return luaL_argerror(L, 2, "no object set in the proxy"); /* create parser and initialise it */ p = XML_ParserCreate("UTF-8"); if (!p) { lua_pushnil(L); lua_pushliteral(L, "Out of memory"); return 2; } data.L = L; data.level = 0; data.interface = 0; data.type = 0; *data.signature = '\0'; *data.result = '\0'; data.sig_next = data.signature; data.res_next = data.result; XML_SetUserData(p, &data); XML_SetElementHandler(p, (XML_StartElementHandler)start_element_handler, (XML_EndElementHandler)end_element_handler); /* now parse the xml document inserting methods as we go */ if (!XML_Parse(p, xml, strlen(xml), 1)) { #ifdef DEBUG fprintf(stderr, "Parse error at line %d:\n%s\n", (int)XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p))); #endif lua_pushnil(L); lua_pushliteral(L, "Error parsing introspection data"); return 2; } /* free the parser */ XML_ParserFree(p); /* return true */ lua_pushboolean(L, 1); return 1; }
xml_node *xml_parse( const char *filename ) { int done = 0; FILE *xptr; XML_Parser p; static char buf[BUFSIZE]; xml_node root, *ret; if( (xptr = fopen( filename, "r" )) == NULL ) { fprintf( stderr, "Unable to open file: %s\n", filename ); return NULL; } root.child = NULL; if( (ret = xml_alloc(&root)) == NULL ) { fclose( xptr ); fprintf( stderr, "Out of memory\n" ); return NULL; } if( (p = XML_ParserCreate( NULL )) == NULL ) { fclose( xptr ); fprintf( stderr, "Out of memory\n" ); return NULL; } XML_SetUserData( p, &ret ); XML_SetElementHandler( p, xml_el_start, xml_el_end ); XML_SetCharacterDataHandler( p, xml_charhndl ); while( !done ) { int len; len = fread( buf, 1, BUFSIZE, xptr ); if( ferror( xptr ) ) { fprintf( stderr, "Read error\n" ); xml_free( ret ); ret = NULL; break; } done = feof( xptr ); if( XML_Parse(p, buf, len, done) == 0 ) { fprintf( stderr, "Parse error at line %d:\n%s\n", (int) XML_GetCurrentLineNumber(p), XML_ErrorString( XML_GetErrorCode(p) ) ); xml_free( ret ); ret = NULL; break; } } if( ret != NULL ) ret->parent = NULL; fclose( xptr ); XML_ParserFree( p ); return ret; }
// Load the tree control with data from the XML file. BOOL CPrefEditView::LoadTreeControl() { CTreeCtrl &treeCtrl = GetTreeCtrl(); m_hgroup = treeCtrl.GetRootItem(); XML_Parser parser = XML_ParserCreate(NULL); XML_SetElementHandler(parser, startElementC, endElementC); XML_SetCharacterDataHandler(parser, characterDataC); XML_SetUserData(parser, this); // Load the XML from the file. CString strPrefsXML; FILE* pFile = fopen(m_strXMLFile, "r"); if (!pFile) { CString strMsg; strMsg.Format("Can't open the file %s.", m_strXMLFile); AfxMessageBox(strMsg, MB_OK); return FALSE; } // obtain file size. fseek(pFile , 0 , SEEK_END); long lSize = ftell(pFile); rewind(pFile); // allocate memory to contain the whole file. char* buffer = (char*) malloc (lSize + 1); if (buffer == NULL) { AfxMessageBox("Memory allocation error.", MB_OK); return FALSE; } buffer[lSize] = '\0'; // copy the file into the buffer. size_t len = fread(buffer,1,lSize,pFile); // The whole file is loaded in the buffer. int done = 0; if (!XML_Parse(parser, buffer, len, done)) { CString strMsg; strMsg.Format("%s in file %s at line %d.",XML_ErrorString(XML_GetErrorCode(parser)), m_strXMLFile, XML_GetCurrentLineNumber(parser)); AfxMessageBox(strMsg, MB_OK); free(buffer); return FALSE; } XML_ParserFree(parser); free(buffer); return TRUE; }
const char* LLXmlParser::getErrorString() { const char* error_string = XML_ErrorString(XML_GetErrorCode( mParser )); if( !error_string ) { error_string = mAuxErrorString.c_str(); } return error_string; }