bool_t restart_parser(parser_t *parser) {
if( parser ) {
parser->cur.rstatus = XML_ResumeParser(parser->p);
return (bool_t)(parser->cur.rstatus == XML_STATUS_OK);
}
return FALSE;
}
void
nsExpatDriver::ParseBuffer(const PRUnichar *aBuffer,
PRUint32 aLength,
PRBool aIsFinal,
PRUint32 *aConsumed)
{
NS_ASSERTION((aBuffer && aLength != 0) || (!aBuffer && aLength == 0), "?");
NS_ASSERTION(mInternalState != NS_OK || aIsFinal || aBuffer,
"Useless call, we won't call Expat");
NS_PRECONDITION(!BlockedOrInterrupted() || !aBuffer,
"Non-null buffer when resuming");
NS_PRECONDITION(XML_GetCurrentByteIndex(mExpatParser) % sizeof(PRUnichar) == 0,
"Consumed part of a PRUnichar?");
if (mExpatParser && (mInternalState == NS_OK || BlockedOrInterrupted())) {
PRInt32 parserBytesBefore = XML_GetCurrentByteIndex(mExpatParser);
NS_ASSERTION(parserBytesBefore >= 0, "Unexpected value");
XML_Status status;
if (BlockedOrInterrupted()) {
mInternalState = NS_OK; // Resume in case we're blocked.
status = XML_ResumeParser(mExpatParser);
}
else {
status = XML_Parse(mExpatParser,
reinterpret_cast<const char*>(aBuffer),
aLength * sizeof(PRUnichar), aIsFinal);
}
PRInt32 parserBytesConsumed = XML_GetCurrentByteIndex(mExpatParser);
NS_ASSERTION(parserBytesConsumed >= 0, "Unexpected value");
NS_ASSERTION(parserBytesConsumed >= parserBytesBefore,
"How'd this happen?");
NS_ASSERTION(parserBytesConsumed % sizeof(PRUnichar) == 0,
"Consumed part of a PRUnichar?");
// Consumed something.
*aConsumed = (parserBytesConsumed - parserBytesBefore) / sizeof(PRUnichar);
NS_ASSERTION(*aConsumed <= aLength + mExpatBuffered,
"Too many bytes consumed?");
NS_ASSERTION(status != XML_STATUS_SUSPENDED || BlockedOrInterrupted(),
"Inconsistent expat suspension state.");
if (status == XML_STATUS_ERROR) {
mInternalState = NS_ERROR_HTMLPARSER_STOPPARSING;
}
}
else {
*aConsumed = 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;
}
enum XML_Status _Expat_XML_ResumeParser(struct ExpatIFace * Self, XML_Parser parser)
{
return XML_ResumeParser(parser);
}
/* 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;
}
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);
}
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;
}
