CExpat::CExpat() { // Open and set up expat to parse the xml P = XML_ParserCreate(NULL); }
ZLXMLReaderInternal::ZLXMLReaderInternal(ZLXMLReader &reader, const char *encoding) : myReader(reader) { myParser = XML_ParserCreate(encoding); myInitialized = false; }
int parser_xml_file(char *path) { int ret = 0; if(NULL == path) { printf("path error!\n"); ret = NO_FILE; return ret; } char *path_buffer = path; FILE *fp = fopen(path_buffer, "r"); if(!fp) { printf("open file error!\n"); ret = NO_FILE; fclose(fp); return ret; } XML_Parser p = XML_ParserCreate(NULL); if(!p) { fprintf(stderr, "Couldn't allocate memory for parser\n"); ret = WRITE_ERROR; fclose(fp); return ret; } XML_SetElementHandler(p, start, end); XML_SetCharacterDataHandler(p, ElementData); for(;;) { int done; int len; len = fread(Buff, 1, BUFF_SIZE, fp); if (ferror(fp)) { fprintf(stderr, "Read error\n"); ret = WRITE_ERROR; break; } done = feof(fp); if(!XML_Parse(p, Buff, len, done)) { fprintf(stderr, "Parse error at line %d:\n%s\n", (int)XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p))); ret = WRITE_ERROR; break; } if (done) break; } fclose(fp); return ret; }
void repo_add_rpmmd(Repo *repo, FILE *fp, const char *language, int flags) { Pool *pool = repo->pool; struct parsedata pd; char buf[BUFF_SIZE]; int i, l; struct stateswitch *sw; Repodata *data; unsigned int now; now = sat_timems(0); data = repo_add_repodata(repo, flags); memset(&pd, 0, sizeof(pd)); 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; } pd.common.pool = pool; pd.common.repo = repo; pd.data = data; pd.content = sat_malloc(256); pd.acontent = 256; pd.lcontent = 0; pd.common.tmp = 0; pd.common.tmpl = 0; pd.kind = 0; pd.language = language; /* initialize the string pool where we will store the package checksums we know about, to get an Id we can use in a cache */ stringpool_init_empty(&pd.cspool); if ((flags & REPO_EXTEND_SOLVABLES) != 0) { /* setup join data */ Dataiterator di; dataiterator_init(&di, pool, repo, 0, SOLVABLE_CHECKSUM, 0, 0); while (dataiterator_step(&di)) { const char *str; int index; if (!sat_chksum_len(di.key->type)) continue; str = repodata_chk2str(di.data, di.key->type, (const unsigned char *)di.kv.str); index = stringpool_str2id(&pd.cspool, str, 1); if (index >= pd.ncscache) { pd.cscache = sat_zextend(pd.cscache, pd.ncscache, index + 1 - pd.ncscache, sizeof(Id), 255); pd.ncscache = index + 1; } pd.cscache[index] = di.solvid; } dataiterator_free(&di); } XML_Parser parser = XML_ParserCreate(NULL); XML_SetUserData(parser, &pd); pd.parser = &parser; 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(pool, SAT_FATAL, "repo_rpmmd: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser)); exit(1); } if (l == 0) break; } XML_ParserFree(parser); sat_free(pd.content); sat_free(pd.lastdirstr); join_freemem(); stringpool_free(&pd.cspool); sat_free(pd.cscache); if (!(flags & REPO_NO_INTERNALIZE)) repodata_internalize(data); POOL_DEBUG(SAT_DEBUG_STATS, "repo_add_rpmmd took %d ms\n", sat_timems(now)); POOL_DEBUG(SAT_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables); POOL_DEBUG(SAT_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", data->incoredatalen/1024, repo->idarraysize / (int)(1024/sizeof(Id))); }
/** * @brief message/inbox/応答メッセージ解析 * @param [IN] xml XMLファイルのフルパス * @param [IN] resp_inf CICレスポンス情報 * @param [IN] personalInfo パーソナルお知らせ情報 * @param [IN] personalInfoNum パーソナルお知らせ情報数 * @return 処理結果(E_SC_RESULT) */ E_SC_RESULT CC_MessageInbox_XmlParse(const Char* xml, T_CC_CMN_SMS_RESPONSE_INFO* resp_inf, INT32 limit, SMPERSONALINFO *personalInfo, INT32 *personalInfoNum, Char *personalNum, SMCALOPT *opt) { E_SC_RESULT ret = e_SC_RESULT_SUCCESS; PERSONALINFO_PARSER personalInfoParser = {}; Char buf[CC_CMN_XML_PARSE_DATA_SIZE + 1] = {}; XML_Parser parser = NULL; INT32 done = 0; INT32 len = 0; INT32 parsedLen = 0; FILE *fp = NULL; SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_START); do { // パラメータチェック if ((NULL == opt) || (true != opt->isResOutputFile)) { if (NULL == xml) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"param error[xml], " HERE); CB_Result = e_SC_RESULT_FAIL; ret = CB_Result; break; } } // 初期化 resp_inf->sts = 0; personalInfoParser.buf = (Char*)SCC_MALLOC(CC_CMN_XML_BUF_SIZE + 1); if (NULL == personalInfoParser.buf) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SCC_MALLOC error, " HERE); CB_Result = e_SC_RESULT_MALLOC_ERR; ret = CB_Result; break; } personalInfoParser.personalInfoMaxNum = limit; personalInfoParser.personalInfo.personalInfoNum = 0; personalInfoParser.personalInfo.personalInfo = personalInfo; personalInfoParser.personalInfo.apiStatus = &resp_inf->apiSts[0]; personalInfoParser.personalInfo.personalNum = personalNum; CB_Result = e_SC_RESULT_SUCCESS; // XMLパーサ生成 parser = XML_ParserCreate(NULL); if (NULL == parser) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"XML_ParserCreate error, " HERE); CB_Result = e_SC_RESULT_FAIL; ret = CB_Result; break; } // コールバック関数設定 XML_SetUserData(parser, &personalInfoParser); XML_SetElementHandler(parser, CC_MessageInbox_StartElement, CC_MessageInbox_EndElement); XML_SetCharacterDataHandler(parser, CC_MessageInbox_CharacterData); if ((NULL == opt) || (true != opt->isResOutputFile)) { CB_IsXmlFile = false; } else { CB_IsXmlFile = true; fp = fopen((char*)opt->resFilePath, "r"); if (NULL == fp) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"file open error(%d)[%s], " HERE, errno, opt->resFilePath); CB_Result = e_SC_RESULT_FILE_ACCESSERR; ret = CB_Result; break; } } while (!done) { if (CC_ISCANCEL()) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"cancel, " HERE); CB_Result = e_SC_RESULT_CANCEL; ret = CB_Result; break; } if (!CB_IsXmlFile) { strncpy((char*)buf, &xml[parsedLen], (sizeof(buf) - 1)); len = (INT32)strlen(buf); parsedLen += len; if (strlen(xml) <= parsedLen) { done = 1; } else { done = 0; } } else { len = (INT32)fread(buf, 1, (sizeof(buf) - 1), fp); done = (len < (sizeof(buf) - 1)); } // XML解析 if ((XML_STATUS_ERROR == XML_Parse(parser, (const char*)buf, len, done)) || (e_SC_RESULT_SUCCESS != CB_Result)) { SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"XML_Parse error(0x%08x), " HERE, CB_Result); CB_Result = e_SC_RESULT_SMS_API_ERR; ret = CB_Result; break; } if (!done) { // バッファクリア memset(buf, 0, (sizeof(buf) - 1)); } } if (e_SC_RESULT_SUCCESS == CB_Result) { *personalInfoNum = personalInfoParser.personalInfo.personalInfoNum; } } while (0); if (NULL != personalInfoParser.buf) { SCC_FREE(personalInfoParser.buf); } if (NULL != fp) { fclose(fp); } if (NULL != parser) { XML_ParserFree(parser); } SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_END); return (ret); }
BOOLEAN ReadInEmailOther(STR fileName, BOOLEAN localizedVersion) { HWFILE hFile; UINT32 uiBytesRead; UINT32 uiFSize; CHAR8 * lpcBuffer; XML_Parser parser = XML_ParserCreate(NULL); EmailOtherParseData pData; DebugMsg(TOPIC_JA2, DBG_LEVEL_3, "Loading EmailOther.xml" ); EmailOther_TextOnly = localizedVersion; // Open file hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE ); if ( !hFile ) return( localizedVersion ); 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, EmailOtherStartElementHandle, EmailOtherEndElementHandle); XML_SetCharacterDataHandler(parser, EmailOtherCharacterDataHandle); memset(&pData,0,sizeof(pData)); XML_SetUserData(parser, &pData); if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE)) { CHAR8 errorBuf[511]; sprintf(errorBuf, "XML Parser Error in EmailOther.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 ); }
int RD_TrimAudio(struct rd_trimaudio *trimaudio[], const char hostname[], const char username[], const char passwd[], const unsigned cartnumber, const unsigned cutnumber, const int trimlevel, unsigned *numrecs) { char post[1500]; char url[1500]; CURL *curl=NULL; XML_Parser parser; struct xml_data xml_data; long response_code; char errbuf[CURL_ERROR_SIZE]; CURLcode res; /* Set number of recs so if fail already set */ *numrecs = 0; /* * Setup the CURL call */ memset(&xml_data,0,sizeof(xml_data)); parser=XML_ParserCreate(NULL); XML_SetUserData(parser,&xml_data); XML_SetElementHandler(parser,__TrimAudioElementStart, __TrimAudioElementEnd); XML_SetCharacterDataHandler(parser,__TrimAudioElementData); snprintf(url,1500,"http://%s/rd-bin/rdxport.cgi",hostname); snprintf(post,1500,"COMMAND=17&LOGIN_NAME=%s&PASSWORD=%s&CART_NUMBER=%u&CUT_NUMBER=%u&TRIM_LEVEL=%d", username,passwd,cartnumber,cutnumber,trimlevel); if((curl=curl_easy_init())==NULL) { return -1; } curl_easy_setopt(curl,CURLOPT_WRITEDATA,parser); curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,__TrimAudioCallback); curl_easy_setopt(curl,CURLOPT_URL,url); curl_easy_setopt(curl,CURLOPT_POST,1); curl_easy_setopt(curl,CURLOPT_POSTFIELDS,post); curl_easy_setopt(curl,CURLOPT_NOPROGRESS,1); curl_easy_setopt(curl,CURLOPT_ERRORBUFFER,errbuf); // curl_easy_setopt(curl,CURLOPT_VERBOSE,1); res = curl_easy_perform(curl); if(res != CURLE_OK) { size_t len = strlen(errbuf); fprintf(stderr, "\nlibcurl error: (%d)", res); if (len) fprintf(stderr, "%s%s", errbuf, ((errbuf[len-1] != '\n') ? "\n" : "")); else fprintf(stderr, "%s\n", curl_easy_strerror(res)); curl_easy_cleanup(curl); return -1; } /* The response OK - so figure out if we got what we wanted.. */ curl_easy_getinfo(curl,CURLINFO_RESPONSE_CODE,&response_code); curl_easy_cleanup(curl); if (response_code > 199 && response_code < 300) { *trimaudio=xml_data.trimaudio; *numrecs = 1; return 0; } else { fprintf(stderr," Call Returned Error: %s\n",xml_data.strbuf); return (int)response_code; } }
//***************************************************************************** bool CHTMLWidget::Parse( //Parse text buffer and add child widgets for each part. // //Params: const CStretchyBuffer &text) //(in) Text to parse. // //Returns: True if parse was successful, false if there was a parse error. { //Renderer init. ClearChildren(); this->wCurrentColumn = this->wX = 0; this->wY = this->wMargin; this->bSkipSpace = true; this->dwCurrentLinkTag = this->dwLinkTagStart; for (int i = First_Tag; i <= Tag_Count; ++i) // Including unknown aeTagLevel[i] = 0; mIdmap.clear(); static const WCHAR defaultColor[] = {We('F'),We('F'),We('F'),We('F'),We('F'),We('F'),We(0)}; this->wstrBGColor = defaultColor; //Parser init. XML_Parser parser = XML_ParserCreate(NULL); XML_SetUserData(parser, this); XML_SetElementHandler(parser, StartElement_cb, EndElement_cb); XML_SetCharacterDataHandler(parser, InElement_cb); // XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_NEVER); bool bResult = true; char *buf = (char*)(BYTE*)text; //size - 2 seems to fix "invalid token" errors at EOF (even at empty files). const UINT size = text.Size() - 2; //Parse the XML. static const char entities[] = "<?xml version=\"1.0\" encoding=\"" "UTF-8" "\"?>" "<!DOCTYPE html [" "<!ENTITY nbsp \"\xc2\xa0\">" //utf-8 for 0xa0 = unicode nbsp "]>"; if ((XML_Parse(parser, entities, strlen(entities), false) == XML_STATUS_ERROR) || (XML_Parse(parser, buf, size, true) == XML_STATUS_ERROR)) { //Some problem occurred. char errorStr[256]; _snprintf(errorStr, 256, "HTML Parse Error: %s at line %u:%u" NEWLINE, XML_ErrorString(XML_GetErrorCode(parser)), (UINT)XML_GetCurrentLineNumber(parser), (UINT)XML_GetCurrentColumnNumber(parser)); CFiles Files; Files.AppendErrorLog((char *)errorStr); #ifdef RUSSIAN_BUILD //Fix unsupported KOI8 encoded Cyrillic chars. // ConvertCyrillicEncodedXMLToUTF8(text); #endif AsciiToUnicode(errorStr, this->wstrStatus); bResult = false; } //Parser clean-up. XML_ParserFree(parser); NewLine(); //once done, ensure final line of text is included in height NewLine(true); //...and have a blank line at the bottom to look good //Render surface to display on screen. bool bCanResize = CanResize(); if (bCanResize) { this->pParent->ScrollAbsolute(0, 0); //scroll to top of page if (this->wY < this->pParent->GetH()) //stretch surface to fill container this->wY = this->pParent->GetH(); } UpdateHTMLSurface(); //Resize (if possible). if (bCanResize) Resize(this->pHTMLSurface->w, this->pHTMLSurface->h); return bResult; }
bool wxXmlDocument::Load(wxInputStream& stream, const wxString& encoding, int flags) { #if wxUSE_UNICODE (void)encoding; #else m_encoding = encoding; #endif const size_t BUFSIZE = 1024; char buf[BUFSIZE]; wxXmlParsingContext ctx; bool done; XML_Parser parser = XML_ParserCreate(NULL); wxXmlNode *root = new wxXmlNode(wxXML_DOCUMENT_NODE, wxEmptyString); ctx.encoding = wxS("UTF-8"); // default in absence of encoding="" ctx.conv = NULL; #if !wxUSE_UNICODE if ( encoding.CmpNoCase(wxS("UTF-8")) != 0 ) ctx.conv = new wxCSConv(encoding); #endif ctx.removeWhiteOnlyNodes = (flags & wxXMLDOC_KEEP_WHITESPACE_NODES) == 0; ctx.parser = parser; ctx.node = root; XML_SetUserData(parser, (void*)&ctx); XML_SetElementHandler(parser, StartElementHnd, EndElementHnd); XML_SetCharacterDataHandler(parser, TextHnd); XML_SetCdataSectionHandler(parser, StartCdataHnd, EndCdataHnd);; XML_SetCommentHandler(parser, CommentHnd); XML_SetProcessingInstructionHandler(parser, PIHnd); XML_SetDefaultHandler(parser, DefaultHnd); XML_SetUnknownEncodingHandler(parser, UnknownEncodingHnd, NULL); bool ok = true; do { size_t len = stream.Read(buf, BUFSIZE).LastRead(); done = (len < BUFSIZE); if (!XML_Parse(parser, buf, len, done)) { wxString error(XML_ErrorString(XML_GetErrorCode(parser)), *wxConvCurrent); wxLogError(_("XML parsing error: '%s' at line %d"), error.c_str(), (int)XML_GetCurrentLineNumber(parser)); ok = false; break; } } while (!done); if (ok) { if (!ctx.version.empty()) SetVersion(ctx.version); if (!ctx.encoding.empty()) SetFileEncoding(ctx.encoding); SetDocumentNode(root); } else { delete root; } XML_ParserFree(parser); #if !wxUSE_UNICODE if ( ctx.conv ) delete ctx.conv; #endif return ok; }
/****f* xml_element/xml_elem_parse_buf * NAME * xml_elem_parse_buf * SYNOPSIS * xml_element* xml_elem_parse_buf(const char* in_buf, int len, XML_ELEM_INPUT_OPTIONS options, XML_ELEM_ERROR error) * FUNCTION * parse a buffer containing XML into an xml_element in-memory tree * INPUTS * in_buf - buffer containing XML document * len - length of buffer * options - input options. optional * error - error result data. optional. check if result is null. * RESULT * void * NOTES * The returned data must be free'd by caller * SEE ALSO * xml_elem_serialize_to_string () * xml_elem_free () * SOURCE */ xml_element* xml_elem_parse_buf(const char* in_buf, int len, XML_ELEM_INPUT_OPTIONS options, XML_ELEM_ERROR error) { xml_element* xReturn = NULL; char buf[100] = ""; static STRUCT_XML_ELEM_INPUT_OPTIONS default_opts = {encoding_utf_8}; if(!options) { options = &default_opts; } if(in_buf) { XML_Parser parser; xml_elem_data mydata = {0}; parser = XML_ParserCreate(NULL); mydata.root = xml_elem_new(); mydata.current = mydata.root; mydata.input_options = options; mydata.needs_enc_conversion = options->encoding && strcmp(options->encoding, encoding_utf_8); XML_SetElementHandler(parser, (XML_StartElementHandler)_xmlrpc_startElement, (XML_EndElementHandler)_xmlrpc_endElement); XML_SetCharacterDataHandler(parser, (XML_CharacterDataHandler)_xmlrpc_charHandler); /* pass the xml_elem_data struct along */ XML_SetUserData(parser, (void*)&mydata); if(!len) { len = strlen(in_buf); } /* parse the XML */ if(XML_Parse(parser, in_buf, len, 1) == 0) { enum XML_Error err_code = XML_GetErrorCode(parser); int line_num = XML_GetCurrentLineNumber(parser); int col_num = XML_GetCurrentColumnNumber(parser); long byte_idx = XML_GetCurrentByteIndex(parser); /* int byte_total = XML_GetCurrentByteCount(parser); */ const char * error_str = XML_ErrorString(err_code); if(byte_idx >= 0) { snprintf(buf, sizeof(buf), "\n\tdata beginning %ld before byte index: %s\n", byte_idx > 10 ? 10 : byte_idx, in_buf + (byte_idx > 10 ? byte_idx - 10 : byte_idx)); } /* fprintf(stderr, "expat reports error code %i\n" "\tdescription: %s\n" "\tline: %i\n" "\tcolumn: %i\n" "\tbyte index: %ld\n" "\ttotal bytes: %i\n%s ", err_code, error_str, line_num, col_num, byte_idx, byte_total, buf); */ /* error condition */ if(error) { error->parser_code = (long)err_code; error->line = line_num; error->column = col_num; error->byte_index = byte_idx; error->parser_error = error_str; } } else { xReturn = (xml_element*)Q_Head(&mydata.root->children); xReturn->parent = NULL; } XML_ParserFree(parser); xml_elem_free_non_recurse(mydata.root); } return xReturn; }
//! Use Expat parser to parse an XML file bool mxflib::XMLParserParseFile(XML_Parser *pParser, mxflib::XMLParserHandlerPtr Hand, void *UserData, const char *filename, bool ParseNamespaces /*=false*/) { if(!Hand) { error("No handler defined in call to XMLParserParseFile()\n"); return false; } // Open the input file FileHandle InFile = FileOpenRead(filename); if(!FileValid(InFile)) { Hand->fatalError(UserData, "Couldn't open file %s\n", filename); return false; } // Build a new parser XML_Parser Parser = ParseNamespaces ? XML_ParserCreateNS(NULL, '|') : XML_ParserCreate(NULL); if(!Parser) { Hand->fatalError(UserData, "Could't create an expat XML parser\n"); FileClose(InFile); return false; } // Set the caller's parser pointer if requested if(pParser) *pParser = Parser; // Set the element handlers XML_SetElementHandler(Parser, Hand->startElement, Hand->endElement); // Set the user data XML_SetUserData(Parser, UserData); int Done = 0; do { const int BufferSize = 1024 * 64; UInt8 *Buffer = (UInt8*)XML_GetBuffer(Parser, BufferSize); int Bytes = (int)FileRead(InFile, Buffer, BufferSize); if(FileEof(InFile)) Done = -1; if (XML_ParseBuffer(Parser, Bytes, Done) == XML_STATUS_ERROR) { Hand->fatalError(UserData, "Parse error at line %d:\n%s\n", XML_GetCurrentLineNumber(Parser), XML_ErrorString(XML_GetErrorCode(Parser))); XML_ParserFree(Parser); FileClose(InFile); return false; } } while(!Done); // Free the parser XML_ParserFree(Parser); FileClose(InFile); return true; }
// load document, auto-recognizing its type, returns NULL in case of failure xml_t * XSD_LoadDocument(char *filename) { xml_t *ret = NULL; int i; vfsfile_t *f; XML_Parser parser = NULL; int len; int filelen; char buf[XML_READ_BUFSIZE]; char document_type[1024]; // FIXME: D-Kure, does FS_ANY handle both the above cases if (!(f = FS_OpenVFS(filename, "rb", FS_ANY))) { return NULL; } filelen = VFS_GETLEN(f); // initialize XML parser parser = XML_ParserCreate(NULL); if (parser == NULL) { Com_Printf("could not open2\n"); goto error; } XML_SetStartElementHandler(parser, XSD_DetectType_OnStartElement); XML_SetUserData(parser, document_type); document_type[0] = 0; while (document_type[0] == 0 && (len = VFS_READ(f, buf, XML_READ_BUFSIZE, NULL)) > 0) { if (XML_Parse(parser, buf, len, 0) != XML_STATUS_OK) { Com_Printf("could not open3\n"); goto error; } } if (document_type[0] == 0) { Com_Printf("could not open4\n"); goto error; } // now we know what document type it is... // parser is no more needed XML_ParserFree(parser); parser = NULL; // fseek to the beginning of the file VFS_SEEK(f, 0, SEEK_SET); // execute loading parser i = 0; while (xsd_mappings[i].document_type != NULL) { if (!strcmp(xsd_mappings[i].document_type, document_type)) { //??? ret = xsd_mappings[i].load_function(f, filelen); break; } i++; } if (ret) { VFS_CLOSE(f); return ret; } error: if (f) VFS_CLOSE(f); if (parser) XML_ParserFree(parser); return NULL; }
BOOL cg_xml_parse(CgXmlParser *parser, CgXmlNodeList *nodeList, const char *data, size_t len) { #if defined DEBUG_XML_RESULT CgString* resdata = NULL; #endif XML_Parser p; CgExpatData expatData; #ifdef CG_SHOW_TIMINGS struct timeval start_time, end_time, elapsed_time; #endif cg_log_debug_l4("Entering...\n"); #ifdef CG_SHOW_TIMINGS gettimeofday(&start_time, NULL); #endif if (!data || len <= 0) return FALSE; p = XML_ParserCreate(NULL); if (!p) return FALSE; /* Fix to get expat parser to work with DLink-routers */ if (data[len-1] == 0) len--; expatData.rootNode = NULL; expatData.currNode = NULL; XML_SetUserData(p, &expatData); XML_SetElementHandler(p, cg_expat_element_start, cg_expat_element_end); XML_SetCharacterDataHandler(p, cg_expat_character_data); parser->parseResult = XML_Parse(p, data, len, 1); XML_ParserFree(p); if (parser->parseResult == 0 /*XML_STATUS_ERROR*/) { if (expatData.rootNode != NULL) cg_xml_node_delete(expatData.rootNode); #if defined DEBUG_XML_RESULT resdata = cg_string_new(); cg_string_naddvalue(resdata,data,len); printf("XML parse Error on data %s\n time used = %ds\n", cg_string_getvalue(resdata), time(NULL)-startTime); cg_string_delete(resdata); #endif return FALSE; } cg_xml_nodelist_add(nodeList, expatData.rootNode); #ifdef CG_SHOW_TIMINGS gettimeofday(&end_time, NULL); timersub(&end_time, &start_time, &elapsed_time); cg_log_debug_s("Parsing XML completed. Elapsed time: " "%ld msec\n", ((elapsed_time.tv_sec*1000) + (elapsed_time.tv_usec/1000))); cg_total_elapsed_time += (elapsed_time.tv_sec*1000000)+ (elapsed_time.tv_usec); cg_log_debug_s("Total elapsed time: %ld msec\n", cg_total_elapsed_time / 1000); #endif #if defined DEBUG_XML_RESULT resdata = cg_string_new(); cg_string_naddvalue(resdata,data,len); printf("XML parse success - time used %ds\n",time(NULL)-startTime); cg_string_delete(resdata); #endif return TRUE; cg_log_debug_l4("Leaving...\n"); }
static int createComponentLoaders() { FILE *fp = NULL; parser_info *parserInfo; char buf[BUFSIZ]; XML_Parser parser = XML_ParserCreate(NULL ); int done; int nCompNums = 0; fp = fopen("/system/etc/omx_codec.xml", "r"); if (fp == NULL ) { DEBUG(DEB_LEV_ERR, "open file error\n"); XML_ParserFree(parser); return OMX_ErrorInsufficientResources; } XML_SetUserData(parser, &nCompNums); XML_SetElementHandler(parser, startElement, endElement); do { int len = (int) fread(buf, 1, sizeof(buf), fp); done = (unsigned) len < sizeof(buf); if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) { DEBUG(DEB_LEV_ERR, "%s at line %u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int) XML_GetCurrentLineNumber(parser)); fclose(fp); XML_ParserFree(parser); return OMX_ErrorInsufficientResources; } } while (!done); XML_ParserFree(parser); fseek(fp, 0, SEEK_SET); if (nCompNums == 0) { DEBUG(DEB_LEV_ERR, "error of %s,OMX_Init is %d\n", __func__, __LINE__); act_loaders = 0; fclose(fp); return OMX_ErrorInsufficientResources; } ActComponentType *act_component; act_loaders = nCompNums; act_component = (ActComponentType *) malloc(sizeof(ActComponentType) * nCompNums); parserInfo = (parser_info *) malloc(sizeof(parser_info)); if(NULL == act_component) { DEBUG(DEB_LEV_ERR, "error of %s,OMX_Init is %d\n", __func__, __LINE__); fclose(fp); return OMX_ErrorInsufficientResources; } memset(parserInfo, 0, sizeof(parser_info)); parserInfo->loadlist = act_component; parserInfo->roleIndex = -1; parser = XML_ParserCreate(NULL); XML_SetUserData(parser, parserInfo); XML_SetCharacterDataHandler(parser, charhandle); XML_SetElementHandler(parser, startElement2, endElement2); parserInfo->compIndex = -1; do { int len = (int) fread(buf, 1, sizeof(buf), fp); done = (unsigned) len < sizeof(buf); if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) { DEBUG(DEB_LEV_ERR, "%s at line %u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int) XML_GetCurrentLineNumber(parser)); free(parserInfo); fclose(fp); XML_ParserFree(parser); return OMX_ErrorInsufficientResources; } } while (!done); loadersList = parserInfo->loadlist; int i =0; XML_ParserFree(parser); fclose(fp); free(parserInfo); return 0; }
int main (int argc, char *argv[]) #endif { XML_Parser parser; char *XMLBuf, *XMLBufEnd, *XMLBufPtr; FILE *fd; struct stat fileAttr; int nrOfLoops, bufferSize, fileSize, i, isFinal; int j = 0, ns = 0; clock_t tstart, tend; double cpuTime = 0.0; if (argc > 1) { if (argv[1][0] == '-') { if (argv[1][1] == 'n' && argv[1][2] == '\0') { ns = 1; j = 1; } else usage(argv[0], 1); } } if (argc != j + 4) usage(argv[0], 1); if (stat (argv[j + 1], &fileAttr) != 0) { fprintf (stderr, "could not access file '%s'\n", argv[j + 1]); return 2; } fd = fopen (argv[j + 1], "r"); if (!fd) { fprintf (stderr, "could not open file '%s'\n", argv[j + 1]); exit(2); } bufferSize = atoi (argv[j + 2]); nrOfLoops = atoi (argv[j + 3]); if (bufferSize <= 0 || nrOfLoops <= 0) { fprintf (stderr, "buffer size and nr of loops must be greater than zero.\n"); exit(3); } XMLBuf = malloc (fileAttr.st_size); fileSize = fread (XMLBuf, sizeof (char), fileAttr.st_size, fd); fclose (fd); i = 0; XMLBufEnd = XMLBuf + fileSize; while (i < nrOfLoops) { XMLBufPtr = XMLBuf; isFinal = 0; if (ns) parser = XML_ParserCreateNS(NULL, '!'); else parser = XML_ParserCreate(NULL); tstart = clock(); do { int parseBufferSize = XMLBufEnd - XMLBufPtr; if (parseBufferSize <= bufferSize) isFinal = 1; else parseBufferSize = bufferSize; if (!XML_Parse (parser, XMLBufPtr, parseBufferSize, isFinal)) { fprintf (stderr, "error '%s' at line %" XML_FMT_INT_MOD \ "u character %" XML_FMT_INT_MOD "u\n", XML_ErrorString (XML_GetErrorCode (parser)), XML_GetCurrentLineNumber (parser), XML_GetCurrentColumnNumber (parser)); free (XMLBuf); XML_ParserFree (parser); exit (4); } XMLBufPtr += bufferSize; } while (!isFinal); tend = clock(); cpuTime += ((double) (tend - tstart)) / CLOCKS_PER_SEC; XML_ParserFree (parser); i++; } free (XMLBuf); printf ("%d loops, with buffer size %d. Average time per loop: %f\n", nrOfLoops, bufferSize, cpuTime / (double) nrOfLoops); return 0; }
void xs_infoset_scan(xsMachine* the) { int c = xsToInteger(xsArgc); Scanner scanner; Scanner* self; xsVars(COUNT); xsTry { self = &scanner; c_memset(self, 0, sizeof(Scanner)); if (c < 1) xsSyntaxError("no buffer"); self->expat = XML_ParserCreate(NULL); xsThrowIfNULL(self->expat); XML_SetUserData(self->expat, self); XML_SetElementHandler(self->expat, scanStartTag, scanStopTag); XML_SetCdataSectionHandler(self->expat, scanStartCdata, scanStopCdata); XML_SetCharacterDataHandler(self->expat, scanCharacter); XML_SetCommentHandler(self->expat, scanComment); XML_SetProcessingInstructionHandler(self->expat, scanProcessingInstruction); XML_SetUnknownEncodingHandler(self->expat, scanUnknownEncoding, NULL); XML_SetSkippedEntityHandler(self->expat, scanEntity); self->result = 1; self->textBuffer = c_malloc(8192); xsThrowIfNULL(self->textBuffer); self->textSize = 8192; self->the = the; xsVar(ATTRIBUTE_PROTOTYPE) = xsGet(xsThis, xsID_attribute); xsVar(CDATA_PROTOTYPE) = xsGet(xsThis, xsID_cdata); xsVar(COMMENT_PROTOTYPE) = xsGet(xsThis, xsID_comment); xsVar(DOCUMENT_PROTOTYPE) = xsGet(xsThis, xsID_document); xsVar(ELEMENT_PROTOTYPE) = xsGet(xsThis, xsID_element); xsVar(NO_NAMESPACE) = xsString(""); xsVar(NO_PREFIX) = xsString(""); xsVar(PATH) = (c > 1) ? xsArg(1) : xsUndefined; xsVar(PI_PROTOTYPE) = xsGet(xsThis, xsID_pi); xsVar(XML_NAMESPACE) = xsGet(xsThis, xsID_xmlnsNamespace); xsVar(XML_PREFIX) = xsGet(xsThis, xsID_xmlnsPrefix); xsResult = xsNewInstanceOf(xsVar(DOCUMENT_PROTOTYPE)); xsSet(xsResult, xsID_encoding, xsString("UTF-8")); xsSet(xsResult, xsID_version, xsString("1.0")); xsVar(CHILDREN) = xsNewInstanceOf(xsArrayPrototype); xsArrayCacheBegin(xsVar(CHILDREN)); xsSet(xsResult, xsID_children, xsVar(CHILDREN)); xsSet(xsResult, xsID_parent, xsNull); xsSet(xsResult, xsID_xmlnsAttributes, xsNull); if (xsIsInstanceOf(xsArg(0), xsChunkPrototype)) { xsStringValue buffer = xsGetHostData(xsArg(0)); xsIntegerValue size = xsToInteger(xsGet(xsArg(0), xsID_length)); self->result = XML_Parse(self->expat, (const char *)buffer, size, 1); } else if (xsTypeOf(xsArg(0)) == xsStringType) { xsStringValue string = xsToString(xsArg(0)); xsIntegerValue stringOffset = 0; xsIntegerValue stringSize = c_strlen(string); while (self->result && (stringOffset < stringSize)) { xsIntegerValue size = stringSize - stringOffset; xsStringValue buffer = (char *)XML_GetBuffer(self->expat, 1024); xsThrowIfNULL(buffer); if (size > 1024) size = 1024; c_memcpy(buffer, string + stringOffset, size); self->result = XML_ParseBuffer(self->expat, size, (size < 1024) ? 1 : 0); stringOffset += size; string = xsToString(xsArg(0)); // @@ gc } } else { xsStreamGetter* streamGetter = xsGetHostData(xsArg(0)); while (self->result) { xsIntegerValue i; xsStringValue p, buffer = (char *)XML_GetBuffer(self->expat, 1024); xsThrowIfNULL(buffer); for (i = 0, p = buffer; i < 1024; i++, p++) { int c = (*(streamGetter->getter))(streamGetter->stream); if (c == C_EOF) break; *p = (char)c; } self->result = XML_ParseBuffer(self->expat, i, (i < 1024) ? 1 : 0); if (i < 1024) break; } } xsDelete(xsResult, xsID_xmlnsAttributes); xsDelete(xsResult, xsID_parent); xsArrayCacheEnd(xsVar(CHILDREN)); if (!self->result) { xsVar(LINE) = xsInteger(XML_GetCurrentLineNumber(self->expat)); xsVar(VALUE) = xsString((char*)XML_ErrorString(XML_GetErrorCode(self->expat))); if (xsHas(xsThis, xsID_reportError)) xsCall3_noResult(xsThis, xsID_reportError, xsVar(PATH), xsVar(LINE), xsVar(VALUE)); xsThrow(xsNewInstanceOf(xsSyntaxErrorPrototype)); } c_free(self->textBuffer); self->textBuffer = NULL; XML_ParserFree(self->expat); self->expat = NULL; } xsCatch { if (self->textBuffer) c_free(self->textBuffer); if (self->expat) XML_ParserFree(self->expat); } }
BOOL XMLDomParser::Parse(StreamInterface& s, XMLElementNode& root) { this->Reset(); size_t pos = s.tell(); DWORD flag = 0; int_r n2 = s.ReadData(&flag, 3); if(n2 == 3 && flag == utf8_signature) { const char* encoding = "UTF-8"; if(stricmp(encoding, m_encoding.c_str()) && m_parser) { XML_ParserFree(m_parser); m_parser = NULL; } m_encoding = encoding; } else { s.Seek(pos); } if(!m_parser) { if(m_encoding.empty()) m_encoding = "GB2312"; m_parser = XML_ParserCreate(m_encoding.c_str()); if(!m_parser) return FALSE; XML_SetUserData(m_parser, this); XML_SetElementHandler(m_parser, &StartElementHandler, &EndElementHandler); XML_SetCharacterDataHandler(m_parser, &CharacterDataHandler); } if(root.m_tagName.empty()) root.SetTagName("XMLRoot"); m_pRootNode = &root; m_stack.push(m_pRootNode); //const char* orglocale = NULL; //if(m_encoding.icompare("GB2312") == 0) // orglocale = setLocaleToGbk(); //else if(g_encoding == encode_ansii && m_encoding.icompare("UTF-8") == 0) // orglocale = setLocaleToGbk(); int_r n; char cBuffer[2048]; while(n = s.ReadData(&cBuffer, 2048), n>=0) { BOOL isFinal = (n < 2048); XML_Status status = XML_Parse(m_parser, cBuffer, (int)n, isFinal); if(status == XML_STATUS_ERROR) { //if(orglocale) setlocale(LC_CTYPE, orglocale); sprintf_k(cBuffer, sizeof(cBuffer), "%s at line:%d col:%d", XML_ErrorString(XML_GetErrorCode(m_parser)), XML_GetCurrentLineNumber(m_parser), XML_GetCurrentColumnNumber(m_parser)); m_errMsg = cBuffer; return FALSE; } if(isFinal) break; } //if(orglocale) setlocale(LC_CTYPE, orglocale); return TRUE; }
/* get the control url from the description, which is in xml format, and set the control_url variable in c equal to the string */ static int Get_Control_Url(UpnpController * c, const char * desc_url, const char * description) { int ret; char host[MAX_HOST_LEN]; char host_port[MAX_HOST_LEN]; short int port; XML_Parser parser; XmlDescData xdescdat = {0, 0, 0, 0, 0, 0, 0}; if((ret = Parse_Url(desc_url, host, NULL, &port)) != OK) { return ret; } sprintf(host_port, "%s:%d", host, port); parser = XML_ParserCreate(NULL); xdescdat.correct_service = (char *)malloc(strlen(SSDP_TARGET) + strlen(c->service_type) + NULL_TERM_LEN); (void)sprintf(xdescdat.correct_service, SSDP_TARGET, c->service_type); XML_SetUserData(parser, &xdescdat); XML_SetElementHandler(parser, Start_Desc_Element, End_Desc_Element); XML_SetCharacterDataHandler(parser, Data_Desc_Handler); if(!XML_Parse(parser, description, (int)strlen(description), 1)) { XML_ParserFree(parser); XmlDescData_Free(xdescdat); return UPNP_BAD_DESCRIPTION; } /* if we didn't find a base url in the description, then it is the same url as the desc_url */ if(NULL == xdescdat.url_base) { xdescdat.url_base = (char *)malloc(strlen(host_port) + NULL_TERM_LEN); strcpy(xdescdat.url_base, host_port); } /* if the control_url contains the http protocol string, then don't prepend the base url to it */ if(strncmp(xdescdat.control_url, HTTP_PROTOCOL_STRING, strlen(HTTP_PROTOCOL_STRING)) == 0) { c->control_url = (char *)malloc(strlen(xdescdat.control_url) + NULL_TERM_LEN); if(NULL == c->control_url) { XmlDescData_Free(xdescdat); return BAD_MALLOC; } strcpy(c->control_url, xdescdat.control_url); } else { c->control_url = (char *)malloc(strlen(xdescdat.url_base)+ strlen(xdescdat.control_url) + NULL_TERM_LEN); if(NULL == c->control_url) { XmlDescData_Free(xdescdat); return BAD_MALLOC; } (void)sprintf(c->control_url, "%s%s", xdescdat.url_base, xdescdat.control_url); } XmlDescData_Free(xdescdat); XML_ParserFree(parser); /* now make sure that the url size is appropriate */ if(strlen(c->control_url)+NULL_TERM_LEN > MAX_URL_LEN) { free(c->control_url); return UPNP_URL_OVER_MAX_LEN; } return OK; }
static int static_service_group_load(StaticServiceGroup *g) { XML_Parser parser = NULL; int fd = -1; struct xml_userdata u; int r = -1; struct stat st; ssize_t n; assert(g); u.buf = NULL; u.group = g; u.service = NULL; u.current_tag = XML_TAG_INVALID; u.failed = 0; /* Cleanup old data in this service group, if available */ remove_static_service_group_from_server(g); while (g->services) static_service_free(g->services); avahi_free(g->name); avahi_free(g->chosen_name); g->name = g->chosen_name = NULL; g->replace_wildcards = 0; if (!(parser = XML_ParserCreate(NULL))) { avahi_log_error("XML_ParserCreate() failed."); goto finish; } if ((fd = open(g->filename, O_RDONLY)) < 0) { avahi_log_error("open(\"%s\", O_RDONLY): %s", g->filename, strerror(errno)); goto finish; } if (fstat(fd, &st) < 0) { avahi_log_error("fstat(): %s", strerror(errno)); goto finish; } g->mtime = st.st_mtime; XML_SetUserData(parser, &u); XML_SetElementHandler(parser, xml_start, xml_end); XML_SetCharacterDataHandler(parser, xml_cdata); do { void *buffer; #define BUFSIZE (10*1024) if (!(buffer = XML_GetBuffer(parser, BUFSIZE))) { avahi_log_error("XML_GetBuffer() failed."); goto finish; } if ((n = read(fd, buffer, BUFSIZE)) < 0) { avahi_log_error("read(): %s\n", strerror(errno)); goto finish; } if (!XML_ParseBuffer(parser, n, n == 0)) { avahi_log_error("XML_ParseBuffer() failed at line %d: %s.\n", (int) XML_GetCurrentLineNumber(parser), XML_ErrorString(XML_GetErrorCode(parser))); goto finish; } } while (n != 0); if (!u.failed) r = 0; finish: if (fd >= 0) close(fd); if (parser) XML_ParserFree(parser); avahi_free(u.buf); return r; }
BOOLEAN ReadInLBEPocketPopups(STR fileName) { HWFILE hFile; UINT32 uiBytesRead; UINT32 uiFSize; CHAR8 * lpcBuffer; XML_Parser parser = XML_ParserCreate(NULL); pocketPopupParseData pData; DebugMsg(TOPIC_JA2, DBG_LEVEL_3, "Loading pocketPopups.xml" ); 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, pocketPopupStartElementHandle, pocketPopupEndElementHandle); XML_SetCharacterDataHandler(parser, pocketPopupCharacterDataHandle); memset(&pData,0,sizeof(pData)); XML_SetUserData(parser, &pData); XML_SetUserData(parser, &pData); if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE)) { CHAR8 errorBuf[511]; sprintf(errorBuf, "XML Parser Error in Pocket.xml: %s at line %d", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser)); LiveMessage(errorBuf); MemFree(lpcBuffer); return FALSE; } /* // dummy popup popupDef* popup = new popupDef(); popup->addOption(new std::wstring(L"Option one"),NULL,NULL); popup->addOption(new std::wstring(L"Option two"),NULL,NULL); popup->addOption(new std::wstring(L"Option three"),NULL,NULL); LBEPocketPopup[5] = *popup; */ MemFree(lpcBuffer); XML_ParserFree(parser); return( TRUE ); }
int main (int argc, char *argv []) { /* main for groom-nmap-xml */ char buff [65536]; int buff_size; int done; FILE *fp; int i; int j; XML_Parser parser; int status; int status_io; status = ST_OK; buff_size = sizeof (buff); if (argc > 1) fprintf (stderr, "Groom NMAP XML 0.0 EP 01\n"); param_verbosity = 2; strcpy (param_results_path, "/tester/current/results"); if (argc > 1) { strcpy (param_results_path, argv [1]); if (argc > 2) { int i; sscanf (argv [1], "%d", &i); param_verbosity = i; }; }; if (param_verbosity > 2) { fprintf (stderr, "collect_nmap: param_verbosity %d\n", param_verbosity); }; cur_netnode = -1; cur_sap = -1; memset (netnodes, 0, sizeof (netnodes)); fp = fopen ("test.in", "r"); if (fp == NULL) { printf ("Failed to open file\n"); status = -1; } if (status EQUALS ST_OK) { parser = XML_ParserCreate (NULL); XML_SetElementHandler(parser, start_element, end_element); XML_SetCharacterDataHandler (parser, handle_data); memset(buff, 0, buff_size); memset((void *)&nctx, 0, sizeof (nctx)); status_io = fread (buff, sizeof(char), buff_size, fp); if (param_verbosity > 1) fprintf (stderr, "Read %d bytes from file\n", status_io); if (status_io EQUALS buff_size) status = -2; if (status EQUALS ST_OK) { /* parse the xml */ if (XML_Parse(parser, buff, strlen(buff), XML_TRUE) == XML_STATUS_ERROR) { printf("Error: %s\n", XML_ErrorString(XML_GetErrorCode(parser))); } }; XML_ParserFree (parser); }; fprintf (stderr, "%d nodes found\n", 1+cur_netnode); done = 0; for (i=0; (!done) && (i<cur_netnode); i++) { char filename [1024]; FILE *ninfo; char s1 [1024]; sprintf (filename, "%s/%06d_node_inventory.json", param_results_path, i); ninfo = fopen (filename, "w"); if (!ninfo) done = 1; if (!done) { fprintf (ninfo, "{\n"); if (strlen (netnodes[i].addr_ieee802) EQUALS 0) strcpy (s1, "(Unknown)"); else strcpy (s1, netnodes[i].addr_ieee802); fprintf (ninfo, " \"ipv4\" : \"%s\",\n \"mac\" : \"%s\",\n", netnodes [i].addr_ipv4, s1); for (j=0; j < netnodes [i].port_count; j++) { fprintf (ninfo, " \"port\" : \"tcp/%s\"", netnodes [i].ports [j].sap_port); if (j != (netnodes[i].port_count-1)) fprintf (ninfo, ","); fprintf (ninfo, "\n"); }; fprintf (ninfo, "}\n"); fclose (ninfo); }; }; if (status != 0) fprintf (stderr, "Status was %d\n", status); return (status); } /* main for groom-nmap-xml */
/* * Initialize an IterParser object * * The Python arguments are: * * *fd*: A Python file object or a callable object * *buffersize*: The size of the read buffer */ static int IterParser_init(IterParser *self, PyObject *args, PyObject *kwds) { PyObject* fd = NULL; PyObject* read = NULL; ssize_t buffersize = 1 << 14; static char *kwlist[] = {"fd", "buffersize", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|n:IterParser.__init__", kwlist, &fd, &buffersize)) { return -1; } /* Keep the buffersize within a reasonable range */ self->buffersize = CLAMP(buffersize, (ssize_t)(1 << 10), (ssize_t)(1 << 24)); #ifdef __clang__ /* Clang can't handle the file descriptors Python gives us, so in that case, we just call the object's read method. */ read = PyObject_GetAttrString(fd, "read"); if (read != NULL) { fd = read; } #else self->file = PyObject_AsFileDescriptor(fd); if (self->file != -1) { /* This is a real C file handle or descriptor. We therefore need to allocate our own read buffer, and get the real C object. */ self->buffer = malloc((size_t)self->buffersize); if (self->buffer == NULL) { PyErr_SetString(PyExc_MemoryError, "Out of memory"); goto fail; } self->fd = fd; Py_INCREF(self->fd); lseek(self->file, 0, SEEK_SET); } else #endif if (PyCallable_Check(fd)) { /* fd is a Python callable */ self->fd = fd; Py_INCREF(self->fd); self->read = fd; Py_INCREF(self->read); } else { PyErr_SetString( PyExc_TypeError, "Arg 1 to iterparser must be a file object or callable object"); goto fail; } PyErr_Clear(); self->queue_read_idx = 0; self->queue_write_idx = 0; self->done = 0; self->text = malloc((size_t)buffersize * sizeof(XML_Char)); self->text_alloc = buffersize; if (self->text == NULL) { PyErr_SetString(PyExc_MemoryError, "Out of memory"); goto fail; } text_clear(self); self->read_args = Py_BuildValue("(n)", buffersize); if (self->read_args == NULL) { goto fail; } self->dict_singleton = PyDict_New(); if (self->dict_singleton == NULL) { goto fail; } self->td_singleton = PyUnicode_FromString("TD"); if (self->td_singleton == NULL) { goto fail; } if (queue_realloc(self, buffersize)) { goto fail; } /* Set up an expat parser with our callbacks */ self->parser = XML_ParserCreate(NULL); if (self->parser == NULL) { PyErr_SetString(PyExc_MemoryError, "Out of memory"); goto fail; } XML_SetUserData(self->parser, self); XML_SetElementHandler( self->parser, (XML_StartElementHandler)startElement, (XML_EndElementHandler)endElement); XML_SetCharacterDataHandler( self->parser, (XML_CharacterDataHandler)characterData); XML_SetXmlDeclHandler( self->parser, (XML_XmlDeclHandler)xmlDecl); Py_XDECREF(read); return 0; fail: Py_XDECREF(read); Py_XDECREF(self->fd); Py_XDECREF(self->read); free(self->text); Py_XDECREF(self->dict_singleton); Py_XDECREF(self->td_singleton); Py_XDECREF(self->read_args); free(self->queue); return -1; }
LLSDXMLParser::Impl::Impl() { mParser = XML_ParserCreate(NULL); reset(); }
int main(int argc, char *argv[], char *envp[]) { int i; FILE *f; char buf[BUFSIZE]; int len; int done; int depth; XML_Parser parser; f = NULL; len = 0; done = 0; depth = 0; if (argc < 2) { fprintf(stderr, "To read from a file:\n\tposm_extractor filename.osm [filename-2.osm ...]\nTo read from stdin:\n\tposm_extractor -\n"); return -1; } fprintf(stdout, "SET NAMES 'utf8' COLLATE 'utf8_unicode_ci';\n"); fprintf(stdout, "SET CHARACTER SET 'utf8';\n"); fprintf(stdout, "SET collation_connection = 'utf8_general_ci';\n"); fprintf(stdout, "DELETE FROM node;\n"); fprintf(stdout, "DELETE FROM tag;\n"); fflush(stdout); for (i = 1; i < argc; i++) { #ifdef DO_FORK pid_t pid = fork(); if (pid == 0) { #endif parser = XML_ParserCreate("UTF-8"); if (parser == NULL) { fprintf(stderr, "Could not initialize parser.\n"); } XML_SetUserData(parser, &depth); XML_SetElementHandler(parser, startElement, endElement); if (strlen(argv[i]) == 1 && argv[i][0] == '-') { f = stdin; } else { f = fopen(argv[i], "rb"); if (f == NULL) { fprintf(stderr, "Could not open '%s'\n", argv[i]); XML_ParserFree(parser); return 1; } } do { len = fread(buf, sizeof(char), BUFSIZE, f); done = feof(f); if (!XML_Parse(parser, buf, len, done)) { fclose(f); fprintf(stderr, "Error (%d): %s at line %d\n", XML_GetErrorCode(parser), XML_ErrorString(XML_GetErrorCode(parser)), (int) XML_GetCurrentLineNumber(parser)); XML_ParserFree(parser); return 1; } } while (!done); if (f != stdin) { fclose(f); } XML_ParserFree(parser); #ifdef DO_FORK return 0; } else if (pid == -1) { perror("fork"); return -1; } #endif } #ifdef DO_FORK while (1) { int status = 0; pid_t pid = wait(&status); if (pid == -1 && errno == ECHILD) { break; } } #endif return 0; }
int RD_EditCart(struct rd_cart *cart[], struct edit_cart_values edit_c_values, const char hostname[], const char username[], const char passwd[], const char ticket[], const unsigned cartnum, const char user_agent[], unsigned *numrecs) { char url[1500]; CURL *curl=NULL; XML_Parser parser; struct xml_data xml_data; long response_code; char errbuf[CURL_ERROR_SIZE]; CURLcode res; char user_agent_string[255]; char cart_buffer[7]; struct curl_httppost *first=NULL; struct curl_httppost *last=NULL; if((curl=curl_easy_init())==NULL) { curl_easy_cleanup(curl); return -1; } /* Set number of recs so if fail already set */ *numrecs = 0; /* * Setup the CURL call */ memset(&xml_data,0,sizeof(xml_data)); parser=XML_ParserCreate(NULL); XML_SetUserData(parser,&xml_data); XML_SetElementHandler(parser,__EditCartElementStart, __EditCartElementEnd); XML_SetCharacterDataHandler(parser,__EditCartElementData); snprintf(url,1500,"http://%s/rd-bin/rdxport.cgi",hostname); curl_formadd(&first, &last, CURLFORM_PTRNAME, "COMMAND", CURLFORM_COPYCONTENTS, "14", CURLFORM_END); curl_formadd(&first, &last, CURLFORM_PTRNAME, "LOGIN_NAME", CURLFORM_COPYCONTENTS, username, CURLFORM_END); curl_formadd(&first, &last, CURLFORM_PTRNAME, "PASSWORD", CURLFORM_COPYCONTENTS, passwd, CURLFORM_END); curl_formadd(&first, &last, CURLFORM_PTRNAME, "TICKET", CURLFORM_COPYCONTENTS, ticket, CURLFORM_END); snprintf(cart_buffer,7,"%u",cartnum); curl_formadd(&first, &last, CURLFORM_PTRNAME, "CART_NUMBER", CURLFORM_COPYCONTENTS, cart_buffer, CURLFORM_END); Build_Post_Cart_Fields(&first,&last,edit_c_values); // Check if User Agent Present otherwise set to default if (strlen(user_agent)> 0){ curl_easy_setopt(curl, CURLOPT_USERAGENT,user_agent); } else { strcpy(user_agent_string, RD_GetUserAgent()); strcat(user_agent_string,VERSION); curl_easy_setopt(curl, CURLOPT_USERAGENT,user_agent_string); } curl_easy_setopt(curl,CURLOPT_WRITEDATA,parser); curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,__EditCartCallback); curl_easy_setopt(curl,CURLOPT_URL,url); curl_easy_setopt(curl,CURLOPT_POST,1); curl_easy_setopt(curl,CURLOPT_HTTPPOST,first); curl_easy_setopt(curl,CURLOPT_NOPROGRESS,1); curl_easy_setopt(curl,CURLOPT_ERRORBUFFER,errbuf); res = curl_easy_perform(curl); if(res != CURLE_OK) { #ifdef RIVC_DEBUG_OUT size_t len = strlen(errbuf); fprintf(stderr, "\nlibcurl error: (%d)", res); if (len) fprintf(stderr, "%s%s", errbuf, ((errbuf[len-1] != '\n') ? "\n" : "")); else fprintf(stderr, "%s\n", curl_easy_strerror(res)); #endif curl_easy_cleanup(curl); return -1; } /* The response OK - so figure out if we got what we wanted.. */ curl_easy_getinfo(curl,CURLINFO_RESPONSE_CODE,&response_code); curl_formfree(first); curl_easy_cleanup(curl); if (response_code > 199 && response_code < 300) { //Success *cart=xml_data.cart; *numrecs = 1; return 0; } else { #ifdef RIVC_DEBUG_OUT fprintf(stderr," rd_editcart Call Returned Error: %s\n",xml_data.strbuf); #endif return (int)response_code; } }
am_config_t *am_parse_config_xml(unsigned long instance_id, const char *xml, size_t xml_sz, char log_enable) { const char *thisfunc = "am_parse_config_xml():"; am_config_t *r = NULL; char *begin, *stream = NULL; size_t data_sz; pcre *x = NULL; const char *error = NULL; int erroroffset; am_xml_parser_ctx_t xctx = {.depth = 0, .setting_value = 0, .conf = NULL, .rgx = NULL, .parser = NULL, .log_enable = log_enable}; if (xml == NULL || xml_sz == 0) { am_log_error(instance_id, "%s memory allocation error", thisfunc); return NULL; } /*match [key]=value returned within <value>[key]=value_of_a_key</value> element*/ x = pcre_compile("(?<=\\[)(.+?)(?=\\])\\]\\s*\\=\\s*(.+)", 0, &error, &erroroffset, NULL); if (x == NULL) { am_log_error(instance_id, "%s pcre error %s", thisfunc, error == NULL ? "" : error); } r = calloc(1, sizeof (am_config_t)); if (r == NULL) { am_log_error(instance_id, "%s memory allocation error", thisfunc); pcre_free(x); return NULL; } r->instance_id = instance_id; begin = strstr(xml, "![CDATA["); if (begin != NULL) { char *end = strstr(begin + 8, "]]>"); if (end != NULL) { stream = begin + 8; data_sz = end - (begin + 8); } } else { /*no CDATA*/ stream = (char *) xml; data_sz = xml_sz; } if (stream != NULL && data_sz > 0) { XML_Parser parser = XML_ParserCreate("UTF-8"); xctx.parser = &parser; xctx.conf = r; xctx.rgx = x; XML_SetUserData(parser, &xctx); XML_SetElementHandler(parser, start_element, end_element); XML_SetCharacterDataHandler(parser, character_data); XML_SetEntityDeclHandler(parser, entity_declaration); if (XML_Parse(parser, stream, (int) data_sz, XML_TRUE) == XML_STATUS_ERROR) { const char *message = XML_ErrorString(XML_GetErrorCode(parser)); int line = XML_GetCurrentLineNumber(parser); int col = XML_GetCurrentColumnNumber(parser); am_log_error(instance_id, "%s xml parser error (%d:%d) %s", thisfunc, line, col, message); am_config_free(&r); r = NULL; } else { r->ts = time(NULL); } XML_ParserFree(parser); } pcre_free(x); return r; }
XML_Parser _Expat_XML_ParserCreate(struct ExpatIFace * Self, const XML_Char *encoding) { return XML_ParserCreate(encoding); }
struct audio_route *audio_route_init(unsigned int card, const char *xml_path) { struct config_parse_state state; XML_Parser parser; FILE *file; int bytes_read; void *buf; int i; struct audio_route *ar; ar = calloc(1, sizeof(struct audio_route)); if (!ar) goto err_calloc; ar->mixer = mixer_open(card); if (!ar->mixer) { ALOGE("Unable to open the mixer, aborting."); goto err_mixer_open; } ar->mixer_path = NULL; ar->mixer_path_size = 0; ar->num_mixer_paths = 0; /* allocate space for and read current mixer settings */ if (alloc_mixer_state(ar) < 0) goto err_mixer_state; /* use the default XML path if none is provided */ if (xml_path == NULL) xml_path = MIXER_XML_PATH; file = fopen(xml_path, "r"); if (!file) { ALOGE("Failed to open %s", xml_path); goto err_fopen; } parser = XML_ParserCreate(NULL); if (!parser) { ALOGE("Failed to create XML parser"); goto err_parser_create; } memset(&state, 0, sizeof(state)); state.ar = ar; XML_SetUserData(parser, &state); XML_SetElementHandler(parser, start_tag, end_tag); for (;;) { buf = XML_GetBuffer(parser, BUF_SIZE); if (buf == NULL) goto err_parse; bytes_read = fread(buf, 1, BUF_SIZE, file); if (bytes_read < 0) goto err_parse; if (XML_ParseBuffer(parser, bytes_read, bytes_read == 0) == XML_STATUS_ERROR) { ALOGE("Error in mixer xml (%s)", MIXER_XML_PATH); goto err_parse; } if (bytes_read == 0) break; } /* apply the initial mixer values, and save them so we can reset the mixer to the original values */ audio_route_update_mixer(ar); save_mixer_state(ar); XML_ParserFree(parser); fclose(file); return ar; err_parse: XML_ParserFree(parser); err_parser_create: fclose(file); err_fopen: free_mixer_state(ar); err_mixer_state: mixer_close(ar->mixer); err_mixer_open: free(ar); ar = NULL; err_calloc: return NULL; }
BOOLEAN ReadInDrugsStats(STR fileName) { HWFILE hFile; UINT32 uiBytesRead; UINT32 uiFSize; CHAR8 * lpcBuffer; XML_Parser parser = XML_ParserCreate(NULL); drugsParseData pData; DebugMsg(TOPIC_JA2, DBG_LEVEL_3, "Loading Drugs.xml" ); // Open drugs 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, drugsStartElementHandle, drugsEndElementHandle); XML_SetCharacterDataHandler(parser, drugsCharacterDataHandle); memset(&pData,0,sizeof(pData)); pData.curArray = Drug; pData.maxArraySize = DRUG_TYPE_MAX; XML_SetUserData(parser, &pData); if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE)) { CHAR8 errorBuf[511]; sprintf(errorBuf, "XML Parser Error in Drugs.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 ngx_http_dav_ext_propfind_handler(ngx_http_request_t *r) { ngx_chain_t *c; ngx_buf_t *b; XML_Parser parser; ngx_uint_t status; ngx_http_dav_ext_ctx_t *ctx; ctx = ngx_http_get_module_ctx(r, ngx_http_dav_ext_module); if (ctx == NULL) { ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_dav_ext_ctx_t)); ngx_http_set_ctx(r, ctx, ngx_http_dav_ext_module); } c = r->request_body->bufs; status = NGX_OK; parser = XML_ParserCreate(NULL); XML_SetUserData(parser, ctx); XML_SetElementHandler(parser, ngx_http_dav_ext_start_xml_elt, ngx_http_dav_ext_end_xml_elt); for(; c != NULL && c->buf != NULL && !c->buf->last_buf; c = c->next) { b = c ->buf; if (!XML_Parse(parser, (const char*)b->pos, b->last - b->pos, b->last_buf)) { ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, "dav_ext propfind XML error"); status = NGX_ERROR; break; } } XML_ParserFree(parser); if (status == NGX_OK) { r->headers_out.status = 207; ngx_str_set(&r->headers_out.status_line, "207 Multi-Status"); ngx_http_send_header(r); ngx_http_finalize_request(r, ngx_http_dav_ext_send_propfind(r)); } else { r->headers_out.status = NGX_HTTP_INTERNAL_SERVER_ERROR; r->header_only = 1; r->headers_out.content_length_n = 0; ngx_http_finalize_request(r, ngx_http_send_header(r)); } }