S32 LLSDXMLParser::Impl::parse(std::istream& input, LLSD& data)
{
XML_Status status;
static const int BUFFER_SIZE = 1024;
void* buffer = NULL;
int count = 0;
while (input.good() && !input.eof())
{
buffer = XML_GetBuffer(mParser, BUFFER_SIZE);
/*
* If we happened to end our last buffer right at the end of the llsd, but the
* stream is still going we will get a null buffer here. Check for mGracefullStop.
*/
if (!buffer)
{
break;
}
count = get_till_eol(input, (char *)buffer, BUFFER_SIZE);
if (!count)
{
break;
}
status = XML_ParseBuffer(mParser, count, false);
if (status == XML_STATUS_ERROR)
{
break;
}
}
// *FIX.: This code is buggy - if the stream was empty or not
// good, there is not buffer to parse, both the call to
// XML_ParseBuffer and the buffer manipulations are illegal
// futhermore, it isn't clear that the expat buffer semantics are
// preserved
status = XML_ParseBuffer(mParser, 0, true);
if (status == XML_STATUS_ERROR && !mGracefullStop)
{
if (buffer)
{
((char*) buffer)[count ? count - 1 : 0] = '\0';
}
if (mEmitErrors)
{
LL_INFOS() << "LLSDXMLParser::Impl::parse: XML_STATUS_ERROR parsing:" << (char*) buffer << LL_ENDL;
}
data = LLSD();
return LLSDParser::PARSE_FAILURE;
}
clear_eol(input);
data = mResult;
return mParseCount;
}
gboolean
lr_xml_parser_generic(XML_Parser parser,
LrParserData *pd,
int fd,
GError **err)
{
/* Note: This function uses .err members of LrParserData! */
gboolean ret = TRUE;
assert(parser);
assert(pd);
assert(fd >= 0);
assert(!err || *err == NULL);
while (1) {
int len;
void *buf = XML_GetBuffer(parser, XML_BUFFER_SIZE);
if (!buf) {
ret = FALSE;
g_set_error(err, LR_XML_PARSER_ERROR, LRE_MEMORY,
"Out of memory: Cannot allocate buffer for xml parser");
break;
}
len = read(fd, (void *) buf, XML_BUFFER_SIZE);
if (len < 0) {
ret = FALSE;
g_debug("%s: Error while reading xml : %s\n",
__func__, strerror(errno));
g_set_error(err, LR_XML_PARSER_ERROR, LRE_IO,
"Error while reading xml: %s", strerror(errno));
break;
}
if (!XML_ParseBuffer(parser, len, len == 0)) {
ret = FALSE;
g_debug("%s: Parse error at line: %d (%s)",
__func__,
(int) XML_GetCurrentLineNumber(parser),
(char *) XML_ErrorString(XML_GetErrorCode(parser)));
g_set_error(err, LR_XML_PARSER_ERROR, LRE_XMLPARSER,
"Parse error at line: %d (%s)",
(int) XML_GetCurrentLineNumber(parser),
(char *) XML_ErrorString(XML_GetErrorCode(parser)));
break;
}
if (pd->err) {
ret = FALSE;
g_propagate_error(err, pd->err);
break;
}
if (len == 0)
break;
}
return ret;
}
bool parseSvnStatus(char*filename,svninfo*svni,mstring*err){
int read;
XMLUDATA udata;
XML_Parser p = XML_ParserCreate(NULL);
udata.status=STPARSE_DEF;
udata.svni=svni;
err->set(NULL);
XML_SetElementHandler(p, startElement, endElement);
XML_SetCharacterDataHandler(p, dataHandler);
XML_SetEncoding(p,"UTF-8");
XML_SetUserData(p, &udata);
FILE*f=fopen(filename, "r");
if(f){
do{
void *buf = XML_GetBuffer(p, BUF_SIZE);
read=fread(buf,1,BUF_SIZE,f);
if (! XML_ParseBuffer(p, read, /*isFinal*/(read == 0) )){
//handle error here
err->sprintf("%s at line %i\n", XML_ErrorString(XML_GetErrorCode(p)), XML_GetCurrentLineNumber(p));
}
}while(read>0 && err->len()==0);
fclose(f);
}else{
err->sprintf("can't open file \"%s\"",filename);
}
XML_ParserFree(p);
return (err->len()==0);
}
static int platform_parse_info(struct platform_data *platform, const char *filename)
{
XML_Parser parser;
FILE *file;
int ret = 0;
int bytes_read;
void *buf;
file = fopen(filename, "r");
if (!file) {
ALOGD("%s: Failed to open %s, using defaults", __func__, filename);
ret = -ENODEV;
goto done;
}
parser = XML_ParserCreate(NULL);
if (!parser) {
ALOGE("%s: Failed to create XML parser!", __func__);
ret = -ENODEV;
goto err_close_file;
}
XML_SetUserData(parser, platform);
XML_SetElementHandler(parser, start_tag, end_tag);
while (1) {
buf = XML_GetBuffer(parser, BUF_SIZE);
if (buf == NULL) {
ALOGE("%s: XML_GetBuffer failed", __func__);
ret = -ENOMEM;
goto err_free_parser;
}
bytes_read = fread(buf, 1, BUF_SIZE, file);
if (bytes_read < 0) {
ALOGE("%s: fread failed, bytes read = %d", __func__, bytes_read);
ret = bytes_read;
goto err_free_parser;
}
if (XML_ParseBuffer(parser, bytes_read,
bytes_read == 0) == XML_STATUS_ERROR) {
ALOGE("%s: XML_ParseBuffer failed, for %s",
__func__, filename);
ret = -EINVAL;
goto err_free_parser;
}
if (bytes_read == 0)
break;
}
err_free_parser:
XML_ParserFree(parser);
err_close_file:
fclose(file);
done:
return ret;
}
BOOL LLXmlParser::parseFile(const std::string &path)
{
llassert( !mDepth );
BOOL success = TRUE;
LLFILE* file = LLFile::fopen(path, "rb"); /* Flawfinder: ignore */
if( !file )
{
mAuxErrorString = llformat( "Couldn't open file %s", path.c_str());
success = FALSE;
}
else
{
S32 bytes_read = 0;
fseek(file, 0L, SEEK_END);
S32 buffer_size = ftell(file);
fseek(file, 0L, SEEK_SET);
void* buffer = XML_GetBuffer(mParser, buffer_size);
if( !buffer )
{
mAuxErrorString = llformat( "Unable to allocate XML buffer while reading file %s", path.c_str() );
success = FALSE;
goto exit_label;
}
bytes_read = (S32)fread(buffer, 1, buffer_size, file);
if( bytes_read <= 0 )
{
mAuxErrorString = llformat( "Error while reading file %s", path.c_str() );
success = FALSE;
goto exit_label;
}
if( !XML_ParseBuffer(mParser, bytes_read, TRUE ) )
{
mAuxErrorString = llformat( "Error while parsing file %s", path.c_str() );
success = FALSE;
}
exit_label:
fclose( file );
}
if( success )
{
llassert( !mDepth );
}
mDepth = 0;
if( !success )
{
LL_WARNS() << mAuxErrorString << LL_ENDL;
}
return success;
}
void MeaXMLParser::ParseBuffer(int len, bool isFinal)
{
if (XML_ParseBuffer(m_parser, len, isFinal) == 0) {
HandleParserError();
throw MeaXMLParserException();
}
}
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;
}
bool XmlParser::InternalParseBuffer( int _len, bool _isFinal )
{
ex_assert( m_pParser, "m_pParser is not create" );
if ( XML_ParseBuffer( m_pParser, _len, _isFinal ) == XML_STATUS_ERROR )
{
this->OnParseError();
return false;
}
return true;
}
bool_t do_parser(parser_t *parser, size_t nbytes) {
int n, fin;
if( parser ) {
n = (nbytes < 0) ? 0 : nbytes;
fin = (nbytes < 0);
parser->cur.rstatus = XML_ParseBuffer(parser->p, n, fin);
return audit_parser(parser);
}
return FALSE;
}
TinyDomElement* TinyDom::parse(std::istream& istr) {
XML_Parser parser = XML_ParserCreate(0);
TinyDomParser tdparser;
XML_SetUserData(parser, &tdparser);
XML_SetCharacterDataHandler(parser, characterDataHandler);
XML_SetElementHandler(parser, startElementHandler, endElementHandler);
XML_SetCommentHandler(parser, commentHandler);
XML_SetProcessingInstructionHandler(parser, processingInstructionHandler);
XML_SetXmlDeclHandler(parser, xmlDeclHandler);
XML_SetDefaultHandler(parser, defaultHandler);
XML_SetDoctypeDeclHandler(parser, startDoctypeDeclHandler, endDoctypeDeclHandler);
try {
while (1) {
void* buf = XML_GetBuffer(parser, 1024);
if (!buf) {
throw std::runtime_error("out of memory!");
}
istr.read((char*)buf, 1024);
std::streamsize len = istr.gcount();
if (istr.fail() && !istr.eof()) {
throw std::runtime_error("failed IO");
}
bool isFinal = (istr.eof() || len < 1024);
if (! XML_ParseBuffer(parser, len, isFinal)) {
std::ostringstream ostr;
ostr << "parse error at line " << XML_GetErrorLineNumber(parser)
<< ", column " << XML_GetErrorColumnNumber(parser) << ": "
<< XML_ErrorString(XML_GetErrorCode(parser));
throw std::runtime_error(ostr.str());
}
if (isFinal) {
break;
}
}
XML_ParserFree(parser);
} catch (...) {
//std::cerr << "Got exception: " << e.what() << "\n";
if (parser) { XML_ParserFree(parser); }
delete tdparser.rootElement;
throw;
}
return tdparser.rootElement;
}
int
_xml_papi_hwi_setup_all_presets( char *arch, hwi_dev_notes_t * notes )
{
int done = 0;
FILE *fp = fopen( "./papi_events.xml", "r" );
XML_Parser p = XML_ParserCreate( NULL );
if ( !p ) {
PAPIERROR( "Couldn't allocate memory for XML parser." );
fclose(fp);
return ( PAPI_ESYS );
}
XML_SetElementHandler( p, _xml_start, _xml_end );
XML_SetCharacterDataHandler( p, _xml_content );
if ( fp == NULL ) {
PAPIERROR( "Error opening Preset XML file." );
fclose(fp);
return ( PAPI_ESYS );
}
xml_arch = arch;
do {
int len;
void *buffer = XML_GetBuffer( p, BUFFSIZE );
if ( buffer == NULL ) {
PAPIERROR( "Couldn't allocate memory for XML buffer." );
fclose(fp);
return ( PAPI_ESYS );
}
len = fread( buffer, 1, BUFFSIZE, fp );
if ( ferror( fp ) ) {
PAPIERROR( "XML read error." );
fclose(fp);
return ( PAPI_ESYS );
}
done = feof( fp );
if ( !XML_ParseBuffer( p, len, len == 0 ) ) {
PAPIERROR( "Parse error at line %d:\n%s",
XML_GetCurrentLineNumber( p ),
XML_ErrorString( XML_GetErrorCode( p ) ) );
fclose(fp);
return ( PAPI_ESYS );
}
if ( error ) {
fclose(fp);
return ( PAPI_ESYS );
}
} while ( !done );
XML_ParserFree( p );
fclose( fp );
return ( PAPI_OK );
}
void XmlReader::Parse() {
#if defined(READER_SUPPORT_XML)
static const int bufsize = 4096;
while (IsOk() && !feof(stream)) {
void* buffer = XML_GetBuffer(parser, bufsize);
int len = fread(buffer, 1, bufsize, stream);
int result = XML_ParseBuffer(parser, len, len <= 0);
if (result == 0)
Error("%s", XML_ErrorString(XML_GetErrorCode(parser)));
}
#endif
}
//-----------------------------------------------------------------------
void ExpatParser::parseXMLFile(XMLHandler& handler,
const Ogre::String& xmlName, const Ogre::String& xmlResourceGroup,
const Ogre::String& schemaName, const Ogre::String& schemaResourceGroup)
{
XML_Parser parser = XML_ParserCreate(NULL);
try
{
MyUserData myUserData;
myUserData.handler = &handler;
if (_locale.get())
myUserData.converter = boost::bind(&expat_to_local, _1, _2, boost::ref(*_locale));
else
myUserData.converter = boost::bind(&expat_to_local_win32, _1, _2, boost::ref(_buffer));
XML_SetUserData(parser, &myUserData);
XML_SetElementHandler(parser, expatStartElementHandler, expatEndElementHandler);
XML_SetCharacterDataHandler(parser, expatCharacterDataHandler);
const size_t MaxBufferSize = 64*1024;
Ogre::DataStreamPtr dataStream = Ogre::ResourceGroupManager::getSingleton().openResource(xmlName, xmlResourceGroup);
bool done;
do
{
void* buffer = XML_GetBuffer(parser, MaxBufferSize);
if (!buffer)
{
OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR,
"Can't allocate buffer while parse XML file '" + xmlName + "'.",
"ExpatParser::parseXMLFile");
}
size_t count = dataStream->read(buffer, MaxBufferSize);
done = dataStream->eof();
if (XML_ParseBuffer(parser, count, done) != XML_STATUS_OK)
{
OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR,
"An error occurred while parsing XML file '" + xmlName +
"' at line " + Ogre::StringConverter::toString(XML_GetCurrentLineNumber(parser)) +
". Additional information: " + XML_ErrorString(XML_GetErrorCode(parser)),
"ExpatParser::parseXMLFile");
}
} while (!done);
}
catch(...)
{
XML_ParserFree(parser);
throw;
}
XML_ParserFree(parser);
}
void XMLParser::parse(int fd, struct callbacks *cb, Osmium::OSM::Node *in_node, Osmium::OSM::Way *in_way, Osmium::OSM::Relation *in_relation) {
int done;
Osmium::OSM::Object *current_object = 0;
callbacks = cb;
node = in_node;
way = in_way;
relation = in_relation;
last_object_type = NODE;
XML_Parser parser = XML_ParserCreate(0);
if (!parser) {
throw std::runtime_error("Error creating parser");
}
XML_SetUserData(parser, (void *) ¤t_object);
XML_SetElementHandler(parser, XMLParser::startElement, XMLParser::endElement);
if (callbacks->before_nodes) { callbacks->before_nodes(); }
do {
void *buffer = XML_GetBuffer(parser, OSMIUM_XMLPARSER_BUFFER_SIZE);
if (buffer == 0) {
throw std::runtime_error("out of memory");
}
int result = read(fd, buffer, OSMIUM_XMLPARSER_BUFFER_SIZE);
if (result < 0) {
exit(1);
}
done = (result == 0);
if (XML_ParseBuffer(parser, result, done) == XML_STATUS_ERROR)
{
XML_Error errorCode = XML_GetErrorCode(parser);
long errorLine = XML_GetCurrentLineNumber(parser);
long errorCol = XML_GetCurrentColumnNumber(parser);
const XML_LChar *errorString = XML_ErrorString(errorCode);
std::stringstream errorDesc;
errorDesc << "XML parsing error at line " << errorLine << ":" << errorCol;
errorDesc << ": " << errorString;
throw std::runtime_error(errorDesc.str());
}
} while (!done);
XML_ParserFree(parser);
error = "";
if (callbacks->after_relations) { callbacks->after_relations(); }
}
void parse_xml(struct config_parse_state *state)
{
XML_Parser parser;
FILE *file;
int bytes_read;
void *buf;
file = fopen(mixer_paths_xml, "r");
if (!file) {
printf("Oooft, cannae open xml file\n");
goto errr;
}
parser = XML_ParserCreate(NULL);
if (!parser) {
printf("Yer arse in parsely!\n");
goto errr;
}
XML_SetUserData(parser, state);
XML_SetElementHandler(parser, start_tag, end_tag);
for (;;) {
buf = XML_GetBuffer(parser, BUF_SIZE);
if (buf == NULL) {
printf("NULL BUFF!\n");
goto errr;
}
bytes_read = fread(buf, 1, BUF_SIZE, file);
if (bytes_read < 0 ) {
printf("Zero bytes read!\n");
goto errr;
}
if (XML_ParseBuffer(parser, bytes_read, bytes_read == 0) == XML_STATUS_ERROR) {
printf("Xml file buggered\n");
goto errr;
}
if (bytes_read == 0)
break;
}
XML_ParserFree(parser);
fclose(file);
return;
errr:
printf("BURNEY! PARSE_XML is aRSE IN PARSELY\n");
exit(-1);
}
//! Use Expat parser to parse an XML file
bool mxflib::XMLParserParseString(XML_Parser *pParser, mxflib::XMLParserHandlerPtr Hand, void *UserData, std::string & strXML, bool ParseNamespaces /*=false*/)
{
if(!Hand)
{
error("No handler defined in call to XMLParserParseFile()\n");
return false;
}
// Build a new parser
XML_Parser Parser = XML_ParserCreate(NULL);
if(!Parser)
{
Hand->fatalError(UserData, "Could't create an expat XML parser\n");
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;
const size_t BufferSize = strXML.size()+1;
char *Buffer = (char *)XML_GetBuffer(Parser, static_cast<int>(BufferSize));
strcpy(Buffer, strXML.c_str());
if (XML_ParseBuffer(Parser, static_cast<int>(BufferSize-1), 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);
return false;
}
// Free the parser
XML_ParserFree(Parser);
return true;
}
static int
processStream(const XML_Char *filename, XML_Parser parser)
{
/* passing NULL for filename means read intput from stdin */
int fd = 0; /* 0 is the fileno for stdin */
if (filename != NULL) {
fd = topen(filename, O_BINARY|O_RDONLY);
if (fd < 0) {
tperror(filename);
return 0;
}
}
for (;;) {
int nread;
char *buf = (char *)XML_GetBuffer(parser, READ_SIZE);
if (!buf) {
if (filename != NULL)
close(fd);
ftprintf(stderr, T("%s: out of memory\n"),
filename != NULL ? filename : "xmlwf");
return 0;
}
nread = read(fd, buf, READ_SIZE);
if (nread < 0) {
tperror(filename != NULL ? filename : "STDIN");
if (filename != NULL)
close(fd);
return 0;
}
if (XML_ParseBuffer(parser, nread, nread == 0) == XML_STATUS_ERROR) {
reportError(parser, filename != NULL ? filename : "STDIN");
if (filename != NULL)
close(fd);
return 0;
}
if (nread == 0) {
if (filename != NULL)
close(fd);
break;;
}
}
return 1;
}
int main(int argc, char **argv) {
AppData *ad;
XML_Parser p = XML_ParserCreateNS(NULL, '|');
if (! p) {
fprintf(stderr, "Couldn't allocate memory for parser\n");
exit(-1);
}
ad = newAppData();
XML_SetUserData(p, (void *) ad);
XML_SetElementHandler(p, start, end);
XML_SetNamespaceDeclHandler(p, ns_start, ns_end);
for (;;) {
char *buff;
int len;
buff = XML_GetBuffer(p, CHUNK_SIZE);
if (! buff) {
fprintf(stderr, "Ran out of memory for parse buffer\n");
exit(-1);
}
len = read(0, buff, CHUNK_SIZE);
if (len < 0) {
perror("namespace - read error");
exit(-1);
}
if (! XML_ParseBuffer(p, len, len == 0)) {
fprintf(stderr, "Parse error at line %lu:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
exit(-1);
}
if (len == 0)
break;
}
return 0;
} /* End main */
core_state::core_state(const std::string& filename) {
if (access(filename.c_str(),R_OK)!=0)
throw core_exception("could not open status file "+filename);
FILE* configfile=fopen(filename.c_str(),"r");
/* parse document */
XML_Parser p=XML_ParserCreate(NULL);
/* set handler and user data*/
XML_SetStartElementHandler(p,(XML_StartElementHandler)&xml_core_status_startelement_handler);
XML_SetUserData(p,(void*)this);
/* read buffer */
for (;;) {
const size_t BUFF_SIZE=4000;
int bytes_read;
void *buff = XML_GetBuffer(p,BUFF_SIZE);
if (buff == NULL) {
/* handle error */
}
bytes_read = fread(buff, 1, BUFF_SIZE, configfile);
if (bytes_read < 0) {
fclose(configfile);
XML_ParserFree(p);
throw core_exception("error while reading file "+filename);
}
if (! XML_ParseBuffer(p, bytes_read, bytes_read == 0)) {
/* handle parse error */
fclose(configfile);
XML_ParserFree(p);
throw core_exception("error while parsing file "+filename);
}
if (bytes_read == 0)
break;
}
XML_ParserFree(p);
fclose(configfile);
}
static void validate(int start,int fd) {
void *buf; int len;
previous=current=start;
expat=XML_ParserCreateNS(NULL,':');
XML_SetElementHandler(expat,&start_element,&end_element);
XML_SetCharacterDataHandler(expat,&characters);
ok=1; any=0;
for(;;) {
buf=XML_GetBuffer(expat,BUFSIZE);
len=read(fd,buf,BUFSIZE);
if(len<0) {
(*er_printf)("error (%s): %s\n",xml,strerror(errno));
wf=ok=0; break;
}
if(!XML_ParseBuffer(expat,len,len==0)) wf=ok=0;
if(!ok||any||len==0) break;
}
XML_ParserFree(expat);
return;
}
int XML_Parser::parse(size_t n)
{
XML_Status status = XML_ParseBuffer(_rep->parser, n, n == 0);
if (!status)
{
if (status == XML_STATUS_ERROR)
{
raise("parse failed");
return -1;
}
if (status == XML_STATUS_SUSPENDED)
{
raise("parse failed");
return -1;
}
}
return _rep->error ? -1 : 0;
}
bool SkXMLParser::parse(SkStream& docStream)
{
ParsingContext ctx(this);
if (!ctx.fXMLParser) {
SkDebugf("could not create XML parser\n");
return false;
}
XML_SetUserData(ctx.fXMLParser, &ctx);
XML_SetElementHandler(ctx.fXMLParser, start_element_handler, end_element_handler);
XML_SetCharacterDataHandler(ctx.fXMLParser, text_handler);
// Disable entity processing, to inhibit internal entity expansion. See expat CVE-2013-0340.
XML_SetEntityDeclHandler(ctx.fXMLParser, entity_decl_handler);
static const int kBufferSize = 512 SkDEBUGCODE( - 507);
bool done = false;
do {
void* buffer = XML_GetBuffer(ctx.fXMLParser, kBufferSize);
if (!buffer) {
SkDebugf("could not buffer enough to continue\n");
return false;
}
size_t len = docStream.read(buffer, kBufferSize);
done = docStream.isAtEnd();
XML_Status status = XML_ParseBuffer(ctx.fXMLParser, SkToS32(len), done);
if (XML_STATUS_ERROR == status) {
XML_Error error = XML_GetErrorCode(ctx.fXMLParser);
int line = XML_GetCurrentLineNumber(ctx.fXMLParser);
int column = XML_GetCurrentColumnNumber(ctx.fXMLParser);
const XML_LChar* errorString = XML_ErrorString(error);
SkDebugf("parse error @%d:%d: %d (%s).\n", line, column, error, errorString);
return false;
}
} while (!done);
return true;
}
bool X3DXMLLoader::load(const char* fileStr, bool ) const
{
static const int BUFF_SIZE = 2*1024*1024;
std::fstream fin;
assert(_handler);
_impl->setHandler(new X3DXMLContentHandler(_handler));
fin.open(fileStr,std::ios::in);
if( !fin.is_open() )
{
cerr << "Could not open file: " << fileStr << endl;
return false;
}
_handler->startDocument();
while(!fin.eof())
{
char* buffer = (char*)XML_GetBuffer(_impl->_parser, BUFF_SIZE);
if(buffer == NULL)
{
cerr << "Could not acquire expat buffer" << endl;
return false;
}
fin.read(buffer, BUFF_SIZE);
if(!XML_ParseBuffer(_impl->_parser, static_cast<int>(fin.gcount()), fin.eof()))
{
// error
cerr << XML_ErrorString(XML_GetErrorCode(_impl->_parser)) << endl;
return false;
}
}
_handler->endDocument();
return true;
}
bool XMLParser::Parse(size_t len, bool isFinal)
{
assert(m_parser != NULL);
return XML_ParseBuffer(m_parser, len, isFinal) != 0;
}
struct audio_route *audio_route_init(void)
{
struct config_parse_state state;
XML_Parser parser;
FILE *file;
int bytes_read;
void *buf;
int i;
struct mixer_path *path;
struct audio_route *ar;
ar = calloc(1, sizeof(struct audio_route));
if (!ar)
goto err_calloc;
ar->mixer = mixer_open(MIXER_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;
file = fopen(MIXER_XML_PATH, "r");
if (!file) {
ALOGE("Failed to open %s", MIXER_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;
}
audio_route_apply_path(ar, "init");
/* apply the initial mixer values, and save them so we can reset the
mixer to the original values */
update_mixer_state(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;
}
S32 LLSDXMLParser::Impl::parseLines(std::istream& input, LLSD& data)
{
XML_Status status = XML_STATUS_OK;
data = LLSD();
static const int BUFFER_SIZE = 1024;
//static char last_buffer[ BUFFER_SIZE ];
//std::streamsize last_num_read;
// Must get rid of any leading \n, otherwise the stream gets into an error/eof state
clear_eol(input);
while( !mGracefullStop
&& input.good()
&& !input.eof())
{
void* buffer = XML_GetBuffer(mParser, BUFFER_SIZE);
/*
* If we happened to end our last buffer right at the end of the llsd, but the
* stream is still going we will get a null buffer here. Check for mGracefullStop.
* -- I don't think this is actually true - zero 2008-05-09
*/
if (!buffer)
{
break;
}
// Get one line
input.getline((char*)buffer, BUFFER_SIZE);
std::streamsize num_read = input.gcount();
//memcpy( last_buffer, buffer, num_read );
//last_num_read = num_read;
if ( num_read > 0 )
{
if (!input.good() )
{ // Clear state that's set when we run out of buffer
input.clear();
}
// Re-insert with the \n that was absorbed by getline()
char * text = (char *) buffer;
if ( text[num_read - 1] == 0)
{
text[num_read - 1] = '\n';
}
}
status = XML_ParseBuffer(mParser, (int)num_read, false);
if (status == XML_STATUS_ERROR)
{
break;
}
}
if (status != XML_STATUS_ERROR
&& !mGracefullStop)
{ // Parse last bit
status = XML_ParseBuffer(mParser, 0, true);
}
if (status == XML_STATUS_ERROR
&& !mGracefullStop)
{
if (mEmitErrors)
{
LL_INFOS() << "LLSDXMLParser::Impl::parseLines: XML_STATUS_ERROR" << LL_ENDL;
}
return LLSDParser::PARSE_FAILURE;
}
clear_eol(input);
data = mResult;
return mParseCount;
}
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;
}
/**
* This routine runs EXPAT parser
*/
Bool XML_ParseStream(File * f, const XMLCallbacks * cb, void * ctx)
{
XML_Parser parser;
Bool ok = False;
/* set up memory management functions */
XML_Memory_Handling_Suite mem;
memset(&mem, 0, sizeof(mem));
mem.malloc_fcn = MEM_Alloc;
mem.realloc_fcn = MEM_Realloc;
mem.free_fcn = MEM_Free;
/* create parser */
parser = XML_ParserCreate_MM(NULL,&mem,NULL);
if (parser) {
int bufsize = 4096;
void * buf = NULL;
Bool done = False;
/* initialize EXPAT */
ExpatContext expat;
expat.ctx = ctx;
expat.cb = (*cb);
STRBUF_Init(&expat.sb);
BUFFER_Init(&expat.buf);
VECTOR_Init(&expat.atts, 0, NULL, NULL);
/* initialize the parser */
XML_SetElementHandler(parser, EXPAT_StartElement, EXPAT_EndElement);
XML_SetCharacterDataHandler(parser, EXPAT_Characters);
XML_SetUserData(parser, &expat);
/*
* By obtaining the buffer from Expat with the XML_GetBuffer,
* we can avoid double copying of the input.
*/
ok = True;
while (ok && !done && (buf = XML_GetBuffer(parser,bufsize)) != NULL) {
int len = -1;
if (!FILE_Eof(f)) {
len = FILE_Read(f, buf, bufsize);
}
if (len <= 0) {
done = True;
len = 0;
}
ok = XML_ParseBuffer(parser, len, done);
}
#if DEBUG
if (!ok) {
enum XML_Error code = XML_GetErrorCode(parser);
int l = XML_GetCurrentLineNumber(parser);
int c = XML_GetCurrentColumnNumber(parser);
Str fname = FILE_Name(f);
const char * msg = XML_ErrorString(code);
if (!fname) fname = TEXT("<noname>");
if (!msg) msg = "<no message>";
# ifdef _WIN32
TRACE4("EXPAT: %s: line %d, column %d: %hs\n",fname,l,c,msg);
# else /* _WIN32 */
TRACE4("EXPAT: %s: line %d, column %d: %s\n",fname,l,c,msg);
# endif /* _WIN32 */
}
#endif /* DEBUG */
if (!buf) ok = False;
/* deallocate parser */
XML_ParserFree(parser);
STRBUF_Destroy(&expat.sb);
BUFFER_Destroy(&expat.buf);
VECTOR_Destroy(&expat.atts);
}
return (ok);
}
HqBool xmlg_p_parse_byte_stream(
xmlGParser *xml_parser,
void *inputStream,
xmlGByteStreamReadCallback fRead)
{
unsigned char *buf ;
int size = 1024 ;
int res ;
int parseResult ;
xmlGParserCommon *c ;
xmlGFilterChain *filter_chain ;
XMLGASSERT(xml_parser != NULL, "xml_parser is NULL");
XMLGASSERT(inputStream != NULL, "inputstream is NULL");
XMLGASSERT(fRead != NULL, "fRead is NULL");
c = xmlg_get_parser_common(xml_parser);
filter_chain = c->filter_chain ;
for (;;) {
if ((buf = (unsigned char *)XML_GetBuffer(xml_parser->ctxt, size)) == NULL) {
xmlg_parser_error_abort(xml_parser, TRUE,
NAME_AND_LENGTH("Unable to allocate XML parse buffer")) ;
break ;
}
if ((res = fRead(inputStream, buf, size)) < 0) {
xmlg_parser_error_abort(xml_parser, TRUE,
NAME_AND_LENGTH("Unable to read XML byte stream")) ;
break ;
}
parseResult = XML_ParseBuffer(xml_parser->ctxt, res, res == 0);
/* Pick up XML parse errors */
if (parseResult != XML_STATUS_OK) {
int errstr_len = 0 ;
const char *errstr ;
errstr = XML_ErrorString(XML_GetErrorCode(xml_parser->ctxt)) ;
if (errstr != NULL)
errstr_len = strlen_int32(errstr) ;
xmlg_parser_error_abort(xml_parser, TRUE, (uint8 *)errstr, errstr_len) ;
break ;
}
if (res == 0)
break ;
/* Pick up thrown errors and parse errors immediately */
if (c->error_abort || c->success_abort)
break ;
}
if (c->error_abort) {
if (c->filter_chain != NULL)
xmlg_fc_execute_undo(filter_chain) ;
return FALSE;
}
return TRUE;
}
enum XML_Status _Expat_XML_ParseBuffer(struct ExpatIFace * Self, XML_Parser parser, int len, int isFinal)
{
return XML_ParseBuffer(parser, len, isFinal);
}
