LowRepomd * low_repomd_parse (const char *repodata) { struct repodata_context ctx; void *buf; int len; int repodata_file; XML_Parser parser; XML_ParsingStatus status; ctx.state = REPODATA_STATE_BEGIN; parser = XML_ParserCreate (NULL); XML_SetUserData (parser, &ctx); XML_SetElementHandler (parser, low_repomd_start_element, low_repomd_end_element); XML_SetCharacterDataHandler (parser, low_repomd_character_data); repodata_file = open (repodata, O_RDONLY); if (repodata_file < 0) { XML_ParserFree (parser); return NULL; } ctx.repomd = malloc (sizeof (LowRepomd)); memset (ctx.repomd, 0, sizeof (LowRepomd)); do { XML_GetParsingStatus (parser, &status); switch (status.parsing) { case XML_SUSPENDED: case XML_PARSING: case XML_INITIALIZED: buf = XML_GetBuffer (parser, XML_BUFFER_SIZE); len = read (repodata_file, buf, XML_BUFFER_SIZE); if (len < 0) { fprintf (stderr, "couldn't read input: %s\n", strerror (errno)); XML_ParserFree (parser); low_repomd_free (ctx.repomd); return NULL; } XML_ParseBuffer (parser, len, len == 0); break; case XML_FINISHED: default: break; } } while (status.parsing != XML_FINISHED); XML_ParserFree (parser); close (repodata_file); return ctx.repomd; }
void _Expat_XML_GetParsingStatus(struct ExpatIFace * Self, XML_Parser parser, XML_ParsingStatus * status) { XML_GetParsingStatus(parser, status); }
enum XML_Status get_pstatus(parser_t *parser) { XML_ParsingStatus status; XML_GetParsingStatus(parser->p, &status); return status.parsing; }
/* params : desc : the document descriptor * out : destination buffer for the paragraph * return : the length of the paragraph * NO_MORE_DATA if there is no more paragraph * or an error code * * parses the next paragraph */ int parse(struct doc_descriptor* desc, char *out) { char buf[BUFSIZE], tmp[BUFSIZE]; XML_ParsingStatus status; struct meta *meta; int len, i; /* initializing next paragraph container */ ((struct ParserState *)(desc->myState))->ch = out; ((struct ParserState *)(desc->myState))->chlen = 0; /* continuing to next paragraph*/ if (((struct ParserState *)(desc->myState))->suspended) { ((struct ParserState *)(desc->myState))->suspended = 0; XML_ResumeParser(desc->parser); } /* filling a new buffer if the last one has been consumed */ if (!((struct ParserState *)(desc->myState))->suspended) { ((struct ParserState *)(desc->myState))->buflen = 0; i = 0; len = read(desc->fd, tmp, BUFSIZE); while(i < len ) { if(strncmp(tmp + i, "\x05", 1)) { strncpy(buf + ((struct ParserState *)(desc->myState))->buflen, tmp + i, 1); ((struct ParserState *)(desc->myState))->buflen += 1; } i++; } } while (!((struct ParserState *)(desc->myState))->suspended && ((struct ParserState *)(desc->myState))->buflen > 0) { /* processing data until a whole paragraph has been parse or end of file is reached */ ((struct ParserState *)(desc->myState))->meta = NULL; /* parsing buffer */ if (XML_Parse(desc->parser, buf, ((struct ParserState *)(desc->myState))->buflen, 0) == XML_STATUS_ERROR) { fprintf(stderr, "Parsing error : %s\n", XML_ErrorString(XML_GetErrorCode(desc->parser))); return SAX_ERROR; } /* filling the metadata linked list if if metadata have been parsed */ while(((struct ParserState *)(desc->myState))->meta_suspended) { meta = desc->meta; /* adding the new metadata at the end of the list */ if (meta == NULL) { desc->meta = ((struct ParserState *)(desc->myState))->meta; } else { while(meta->next != NULL) { meta = meta->next; } meta->next = ((struct ParserState *)(desc->myState))->meta; } /* resuming parsing */ ((struct ParserState *)(desc->myState))->meta_suspended = 0; XML_ResumeParser(desc->parser); } /* filling new buffer if the last one has been consumed */ XML_GetParsingStatus(desc->parser, &status); if (status.parsing != XML_SUSPENDED) { ((struct ParserState *)(desc->myState))->buflen = 0; i = 0; len = read(desc->fd, tmp, BUFSIZE); while(i < len ) { if(strncmp(tmp + i, "\x05", 1)) { strncpy(buf + ((struct ParserState *)(desc->myState))->buflen, tmp + i, 1); ((struct ParserState *)(desc->myState))->buflen += 1; } i++; } } } /* end of file has been reached */ if (((struct ParserState *)(desc->myState))->buflen == 0) { /* resuming parsing if needed (this shouldn't happen) */ if (((struct ParserState *)(desc->myState))->suspended) { XML_ResumeParser(desc->parser); } /* signaling the end to the parser */ if (XML_Parse(desc->parser, buf, 0, 1) == XML_STATUS_ERROR) { fprintf(stderr, "Parsing error : %s\n", XML_ErrorString(XML_GetErrorCode(desc->parser))); return SAX_ERROR; } return NO_MORE_DATA; } return ((struct ParserState *)(desc->myState))->chlen; }
/* * Starts parsing. The XML data being parsed should be set either set as * a buffer in OSCTXT (pctxt->buffer) or read from its stream (pctxt->pStream). */ int rtSaxCParse (OSXMLREADER* pReader) { long len; enum XML_Status stat = XML_STATUS_OK; struct OSRTSTREAM* pStream; XMLReaderImpl* readerImpl = (XMLReaderImpl*)(void*)pReader; OSCTXT* pctxt; OSSAXHandlerBase* pSaxBase; if (pReader == 0 || pReader->pctxt == 0 || readerImpl->parser == 0) return RTERR_NOTINIT; pctxt = pReader->pctxt; pStream = pctxt->pStream; rtxErrReset (pctxt); pSaxBase = (OSSAXHandlerBase*)readerImpl->userData; if (pStream == 0) { /* stream is not set - parse just a buffer */ stat = XML_Parse (readerImpl->parser, (char*)OSRTBUFPTR(pctxt), (int)pctxt->buffer.size, TRUE); return (stat == XML_STATUS_ERROR) ? RTERR_XMLPARSE : 0; } else { /* read from stream and parse */ do { void* pbuf; XML_Bool isFinal; /* get the buffer to read in */ pbuf = XML_GetBuffer (readerImpl->parser, XML_BUF_SIZE); /* read data to the buffer */ len = rtxStreamRead (pctxt, (OSOCTET*)pbuf, XML_BUF_SIZE); if (len < 0) break; isFinal = (XML_Bool)(!len); /* parse the data in the buffer */ if ((stat = XML_ParseBuffer (readerImpl->parser, len, isFinal)) == 0) break; /* the following code is necessary only if it is necessary to * decode several XML documents consequently from one stream. */ if (pSaxBase->mState == OS_SAX_FINAL_STATE) { /* if parsing is finished, but buffer is not empty we need * to find the beginning of the next XML message and set * this piece of data as pre-read buffer for BufferedStream.*/ XML_ParsingStatus status; XML_GetParsingStatus(readerImpl->parser, &status); if (status.parsing == XML_SUSPENDED) { int offset, lenn; /* Get buffer pointer, offset and length of remaining data. Note, that patching of Expat is necessary to fix two problems: 1) even if parser is stopped by XML_StopParser, it will return error "junk after end-of-document" if buffer is not empty; 2) XML_GetInputContext worked only if macro XML_CONTEXT_BYTES was defined. But it could work even without it. */ const char * _pbuf = XML_GetInputContext(readerImpl->parser, &offset, &lenn); if (offset > 0 && lenn - offset > 0) { int stat = 0; const OSUTF8CHAR* prereadBuf = (const OSUTF8CHAR*)_pbuf + offset; size_t prereadBufLen = (size_t)(lenn - offset), i; /* check, is the buffer just whitespaces or not. If yes, discard it */ for (i = 0; i < prereadBufLen; i++) { if (!OS_ISSPACE (prereadBuf[i])) { if (OSRTSTREAM_ID (pctxt) != OSRTSTRMID_DIRECTBUF) { stat = rtxStreamBufferedCreate (pctxt, OSRTSTRMCM_RESTORE_UNDERLAYING_AFTER_RESET); if (stat < 0) len = stat; } if (stat == 0) { stat = rtxStreamBufferedSetPreReadBuf (pctxt, (const OSOCTET*)prereadBuf + i, prereadBufLen - i); if (stat < 0) len = stat; } break; } } } stat = XML_STATUS_OK; } break; } } while (len > 0); } if (len < 0) { return LOG_RTERR (pctxt, len); } else if (stat != XML_STATUS_OK) { XML_LChar str[256]; len = RTERR_XMLPARSE; EXML_ErrorString (readerImpl->parser, XML_GetErrorCode (readerImpl->parser), str, sizeof(str)/sizeof(str[0])); LOG_RTERRNEW (pctxt, len); rtxErrAddStrParm (pctxt, LSTRX (pctxt, str)); return len; } return 0; }
struct razor_set * razor_set_create_from_yum(void) { struct yum_context ctx; void *buf; int len, ret; gzFile primary, filelists; XML_ParsingStatus status; ctx.importer = razor_importer_create(); ctx.state = YUM_STATE_BEGIN; ctx.primary_parser = XML_ParserCreate(NULL); XML_SetUserData(ctx.primary_parser, &ctx); XML_SetElementHandler(ctx.primary_parser, yum_primary_start_element, yum_primary_end_element); XML_SetCharacterDataHandler(ctx.primary_parser, yum_character_data); ctx.filelists_parser = XML_ParserCreate(NULL); XML_SetUserData(ctx.filelists_parser, &ctx); XML_SetElementHandler(ctx.filelists_parser, yum_filelists_start_element, yum_filelists_end_element); XML_SetCharacterDataHandler(ctx.filelists_parser, yum_character_data); primary = gzopen("primary.xml.gz", "rb"); if (primary == NULL) return NULL; filelists = gzopen("filelists.xml.gz", "rb"); if (filelists == NULL) return NULL; ctx.current_parser = ctx.primary_parser; ctx.current = 0; do { XML_GetParsingStatus(ctx.current_parser, &status); switch (status.parsing) { case XML_SUSPENDED: ret = XML_ResumeParser(ctx.current_parser); break; case XML_PARSING: case XML_INITIALIZED: buf = XML_GetBuffer(ctx.current_parser, XML_BUFFER_SIZE); if (ctx.current_parser == ctx.primary_parser) len = gzread(primary, buf, XML_BUFFER_SIZE); else len = gzread(filelists, buf, XML_BUFFER_SIZE); if (len < 0) { fprintf(stderr, "couldn't read input: %s\n", strerror(errno)); return NULL; } XML_ParseBuffer(ctx.current_parser, len, len == 0); break; case XML_FINISHED: break; } } while (status.parsing != XML_FINISHED); XML_ParserFree(ctx.primary_parser); XML_ParserFree(ctx.filelists_parser); gzclose(primary); gzclose(filelists); printf ("\nsaving\n"); return razor_importer_finish(ctx.importer); }
void bmx_expat_XML_GetParsingStatus(XML_Parser parser, XML_Parsing * parsing, int * finalBuffer) { XML_ParsingStatus status; XML_GetParsingStatus(parser, &status); *parsing = status.parsing; *finalBuffer = status.finalBuffer; }
bool OMXMLReaderExpat::next() { TRACE("OMXMLReaderExpat::next"); if (_status == false) { return _status; } while (_status && nextEvent() == NONE) { if (!_readNextChunk) { int ret = XML_ResumeParser(_parser); if (ret == XML_STATUS_ERROR) { XML_Error errorCode = XML_GetErrorCode(_parser); if (errorCode == XML_ERROR_NOT_SUSPENDED) { XML_ParsingStatus pStatus; XML_GetParsingStatus(_parser, &pStatus); if (pStatus.parsing == XML_FINISHED) { // finished _status = false; } else { _readNextChunk = true; } } else { throw OMException(getErrorString()); } } } if (_readNextChunk) { void* buffer = XML_GetBuffer(_parser, READ_CHUNK_SIZE); _numInBuffer = readNextChunk(buffer, READ_CHUNK_SIZE); int ret = XML_ParseBuffer(_parser, _numInBuffer, _numInBuffer < READ_CHUNK_SIZE); if (ret == XML_STATUS_ERROR) { throw OMException(getErrorString()); } if (_status) { XML_ParsingStatus pStatus; XML_GetParsingStatus(_parser, &pStatus); if (pStatus.parsing == XML_FINISHED) { if (_numInBuffer < READ_CHUNK_SIZE) { _status = false; } else { _readNextChunk = true; } } else { _readNextChunk = false; } } } } return _status; }