/**
* Reports a descriptor error. Does not set the parser to error state but
* increments the error count, unless this is merely a warning.
*
* @param context the parsing context
* @param warn whether this is only a warning
* @param error_msg the error message
* @param ... parameters for the error message
*/
static void descriptor_errorf(ploader_context_t *plcontext, int warn,
const char *error_msg, ...) {
va_list ap;
char message[128];
va_start(ap, error_msg);
vsnprintf(message, sizeof(message), error_msg, ap);
va_end(ap);
message[127] = '\0';
if (warn) {
cpi_warnf(plcontext->context,
N_("Suspicious plug-in descriptor content in %s, line %d, column %d (%s)."),
plcontext->file,
XML_GetCurrentLineNumber(plcontext->parser),
XML_GetCurrentColumnNumber(plcontext->parser) + 1,
message);
} else {
cpi_errorf(plcontext->context,
N_("Invalid plug-in descriptor content in %s, line %d, column %d (%s)."),
plcontext->file,
XML_GetCurrentLineNumber(plcontext->parser),
XML_GetCurrentColumnNumber(plcontext->parser) + 1,
message);
}
if (!warn) {
plcontext->error_count++;
}
}
result_t XmlParser::parse(XmlDocument* doc, exlib::string source)
{
XmlParser parser(doc, true);
parser.m_now = doc;
parser.m_list.push_back(doc);
XML_Parser xml_parser = XML_ParserCreate(NULL);
XML_SetParamEntityParsing(xml_parser, XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE);
XML_SetUserData(xml_parser, &parser);
XML_SetXmlDeclHandler(xml_parser, XmlDeclHandler);
XML_SetElementHandler(xml_parser, StartElementHandler, EndElementHandler);
XML_SetCharacterDataHandler(xml_parser, CharacterDataHandler);
XML_SetProcessingInstructionHandler(xml_parser, ProcessingInstructionHandler);
XML_SetCommentHandler(xml_parser, CommentHandler);
XML_SetCdataSectionHandler(xml_parser, StartCdataSectionHandler, EndCdataSectionHandler);
XML_SetStartDoctypeDeclHandler(xml_parser, StartDoctypeDeclHandler);
if (XML_Parse(xml_parser, source.c_str(), (int32_t)source.length(), true) != XML_STATUS_OK) {
char msg[128];
sprintf(msg, "XmlParser: error on line %lu at column %lu: %s", XML_GetCurrentLineNumber(xml_parser),
XML_GetCurrentColumnNumber(xml_parser) + 1,
XML_ErrorString(XML_GetErrorCode(xml_parser)));
XML_ParserFree(xml_parser);
return CHECK_ERROR(Runtime::setError(msg));
}
XML_ParserFree(xml_parser);
return 0;
}
INLINE void unknown_attribute(parse_state *state, const char *attrname)
{
parse_error(state, "[%lu:%lu]: Unknown attribute: %s\n",
XML_GetCurrentLineNumber(state->parser),
XML_GetCurrentColumnNumber(state->parser),
attrname);
}
exception::exception(
XML_Parser parser)
{
try
{
stringstream s;
XML_Error error = XML_GetErrorCode(parser);
if (error <= XML_ERROR_RESERVED_NAMESPACE_URI)
s << kXML_Parser_Error_Messages[error];
else
s << "Unknown Expat error code";
s << endl
<< "Parse error at line " << XML_GetCurrentLineNumber(parser)
<< " column " << XML_GetCurrentColumnNumber(parser)
<< ":" << endl;
int offset = 0, size = 0;
const char* context = XML_GetInputContext(parser, &offset, &size);
if (context != NULL)
s << string(context + offset, size) << endl;
m_message = s.str();
}
catch (...)
{
m_message = "oeps";
}
}
INLINE void unknown_tag(parse_state *state, const char *tagname)
{
parse_error(state, "[%lu:%lu]: Unknown tag: %s\n",
XML_GetCurrentLineNumber(state->parser),
XML_GetCurrentColumnNumber(state->parser),
tagname);
}
static void verror_handler(int erno,va_list ap) {
if(erno&ERBIT_RNL) {
rnl_default_verror_handler(erno&~ERBIT_RNL,ap);
} else {
int line=XML_GetCurrentLineNumber(expat),col=XML_GetCurrentColumnNumber(expat);
if(line!=lastline||col!=lastcol) { lastline=line; lastcol=col;
if(xgfile) (*er_printf)("%s:%s: error: ",xgfile,xgpos); else
(*er_printf)("%s:%i:%i: error: ",xml,line,col);
if(erno&ERBIT_RNV) {
rnv_default_verror_handler(erno&~ERBIT_RNV,ap);
if(nexp) { int req=2, i=0; char *s;
while(req--) {
rnx_expected(previous,req);
if(i==rnx_n_exp) continue;
if(rnx_n_exp>nexp) break;
(*er_printf)((char*)(req?"required:\n":"allowed:\n"));
for(;i!=rnx_n_exp;++i) {
(*er_printf)("\t%s\n",s=rnx_p2str(rnx_exp[i]));
m_free(s);
}
}
}
} else {
switch(erno) {
case XCL_ER_IO: err("%s"); break;
case XCL_ER_XML: err("%s"); break;
case XCL_ER_XENT: err("pipe through xx to expand external entities"); break;
default: assert(0);
}
}
}
}
}
bool WgResourceSerializerXML::BuildXMLTree( const char * pXML, int nBytes )
{
m_xmlStackIn.clear();
XML_Parser hParser;
// create parser
hParser = XML_ParserCreate( "UTF-8" );
XML_SetUserData( hParser, this );
XML_SetElementHandler( hParser, cbStartXMLTag, cbEndXMLTag );
XML_SetCharacterDataHandler( hParser, cbXMLText );
int iRet = XML_Parse( hParser, pXML, nBytes, 1 );
if( iRet == XML_STATUS_ERROR )
{
XML_Error errCode = XML_GetErrorCode( hParser );
int errLine = XML_GetCurrentLineNumber( hParser );
int errColumn = XML_GetCurrentColumnNumber( hParser );
std::stringstream ss;
ss << "XML parser error " << (int)errCode << " (Ln " << errLine << " Col " << errColumn << "): " << XML_ErrorString(errCode);
Error(ss.str());
}
XML_ParserFree( hParser );
return iRet == XML_STATUS_OK;
}
xml_data_node *xml_string_read(const char *string, xml_parse_options *opts)
{
xml_parse_info parse_info;
int length = strlen(string);
/* set up the parser */
if (!setup_parser(&parse_info, opts))
return NULL;
/* parse the data */
if (XML_Parse(parse_info.parser, string, length, TRUE) == XML_STATUS_ERROR)
{
if (opts && opts->error)
{
opts->error->error_message = XML_ErrorString(XML_GetErrorCode(parse_info.parser));
opts->error->error_line = XML_GetCurrentLineNumber(parse_info.parser);
opts->error->error_column = XML_GetCurrentColumnNumber(parse_info.parser);
}
xml_file_free(parse_info.rootnode);
XML_ParserFree(parse_info.parser);
return NULL;
}
/* free the parser */
XML_ParserFree(parse_info.parser);
/* return the root node */
return parse_info.rootnode;
}
xml_data_node *xml_data_node::string_read(const char *string, xml_parse_options const *opts)
{
xml_parse_info info;
int length = (int)strlen(string);
/* set up the parser */
if (!expat_setup_parser(info, opts))
return nullptr;
/* parse the data */
if (XML_Parse(info.parser, string, length, 1) == XML_STATUS_ERROR)
{
if (opts != nullptr && opts->error != nullptr)
{
opts->error->error_message = XML_ErrorString(XML_GetErrorCode(info.parser));
opts->error->error_line = XML_GetCurrentLineNumber(info.parser);
opts->error->error_column = XML_GetCurrentColumnNumber(info.parser);
}
info.rootnode->file_free();
XML_ParserFree(info.parser);
return nullptr;
}
/* free the parser */
XML_ParserFree(info.parser);
/* return the root node */
return info.rootnode;
}
/* Returns error string (extended) */
const XML_LChar* EXML_ErrorString
(XML_Parser parser, enum XML_Error code, XML_LChar* buf, int bufSize)
{
const XML_LChar *err = XML_ErrorString (code);
int i, len;
char str[256], linebuf[32], colbuf[32];
if (err == 0 || buf == 0 || bufSize == 0) {
return err;
}
for (len = 0; err[len] != 0; len++)
;
rtxIntToCharStr
(XML_GetCurrentLineNumber(parser), linebuf, sizeof(linebuf), 0);
rtxIntToCharStr
(XML_GetCurrentColumnNumber(parser), colbuf, sizeof(colbuf), 0);
rtxStrcpy (str, sizeof(str), ", line = ");
rtxStrcat (str, sizeof(str), linebuf);
rtxStrcat (str, sizeof(str), ", column = ");
rtxStrcat (str, sizeof(str), colbuf);
if (bufSize + 1 < len)
return err;
OSCRTLMEMCPY (buf, err, sizeof(XML_LChar)*len);
for (i = 0; (i + len + 1) < bufSize && str[i] != 0; i++) {
buf[i + len] = (XML_LChar)str[i];
}
buf[i + len] = 0;
return buf;
}
void KML::parse()
{
std::size_t nDone = 0;
std::size_t nLen = 0;
char aBuf[BUFSIZ] = { 0 };
if( NULL == pKMLFile_ )
{
sError_ = "No file given";
return;
}
if(poTrunk_ != NULL) {
delete poTrunk_;
poTrunk_ = NULL;
}
if(poCurrent_ != NULL)
{
delete poCurrent_;
poCurrent_ = NULL;
}
XML_Parser oParser = OGRCreateExpatXMLParser();
XML_SetUserData(oParser, this);
XML_SetElementHandler(oParser, startElement, endElement);
XML_SetCharacterDataHandler(oParser, dataHandler);
oCurrentParser = oParser;
nWithoutEventCounter = 0;
do
{
nDataHandlerCounter = 0;
nLen = (int)VSIFReadL( aBuf, 1, sizeof(aBuf), pKMLFile_ );
nDone = VSIFEofL(pKMLFile_);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of KML file failed : %s at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
(int)XML_GetCurrentLineNumber(oParser),
(int)XML_GetCurrentColumnNumber(oParser));
XML_ParserFree(oParser);
VSIRewindL(pKMLFile_);
return;
}
nWithoutEventCounter ++;
} while (!nDone && nLen > 0 && nWithoutEventCounter < 10);
XML_ParserFree(oParser);
VSIRewindL(pKMLFile_);
poCurrent_ = NULL;
if (nWithoutEventCounter == 10)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Too much data inside one element. File probably corrupted");
}
}
static int lxp_pos (lua_State *L) {
lxp_userdata *xpu = checkparser(L, 1);
XML_Parser p = xpu->parser;
lua_pushnumber(L, XML_GetCurrentLineNumber(p));
lua_pushnumber(L, XML_GetCurrentColumnNumber(p) + 1);
lua_pushnumber(L, XML_GetCurrentByteIndex(p) + 1);
return 3;
}
GMLFeature *GMLReader::NextFeature()
{
if (!m_bReadStarted)
{
if (oParser == NULL)
SetupParser();
if (fpGML == NULL)
fpGML = VSIFOpenL(m_pszFilename, "rt");
m_bReadStarted = TRUE;
}
if (fpGML == NULL || m_bStopParsing)
return NULL;
if (nFeatureTabIndex < nFeatureTabLength)
{
return ppoFeatureTab[nFeatureTabIndex++];
}
if (VSIFEofL(fpGML))
return NULL;
char aBuf[BUFSIZ];
CPLFree(ppoFeatureTab);
ppoFeatureTab = NULL;
nFeatureTabLength = 0;
nFeatureTabIndex = 0;
int nDone;
do
{
m_poGMLHandler->ResetDataHandlerCounter();
unsigned int nLen =
(unsigned int)VSIFReadL( aBuf, 1, sizeof(aBuf), fpGML );
nDone = VSIFEofL(fpGML);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of GML file failed : %s "
"at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
(int)XML_GetCurrentLineNumber(oParser),
(int)XML_GetCurrentColumnNumber(oParser));
m_bStopParsing = TRUE;
}
if (!m_bStopParsing)
m_bStopParsing = m_poGMLHandler->HasStoppedParsing();
} while (!nDone && !m_bStopParsing && nFeatureTabLength == 0);
return (nFeatureTabLength) ? ppoFeatureTab[nFeatureTabIndex++] : NULL;
}
/*
* Handle the XML declaration so that we can determine its encoding.
*/
static void
xmlDecl(IterParser *self, const XML_Char *version,
const XML_Char *encoding, int standalone)
{
PyObject* tuple = NULL;
PyObject* xml_str = NULL;
PyObject* attrs = NULL;
PyObject* encoding_str = NULL;
PyObject* version_str = NULL;
if (self->queue_write_idx < self->queue_size) {
tuple = PyTuple_New(4);
if (tuple == NULL) {
XML_StopParser(self->parser, 0);
return;
}
Py_INCREF(Py_True);
PyTuple_SET_ITEM(tuple, 0, Py_True);
xml_str = PyUnicode_FromString("xml");
PyTuple_SET_ITEM(tuple, 1, xml_str);
attrs = PyDict_New();
if (encoding) {
encoding_str = PyUnicode_FromString(encoding);
} else {
encoding_str = PyUnicode_FromString("");
}
PyDict_SetItemString(attrs, "encoding", encoding_str);
Py_DECREF(encoding_str);
if (version) {
version_str = PyUnicode_FromString(version);
} else {
version_str = PyUnicode_FromString("");
}
PyDict_SetItemString(attrs, "version", version_str);
Py_DECREF(version_str);
PyTuple_SET_ITEM(tuple, 2, attrs);
self->last_line = (unsigned long)XML_GetCurrentLineNumber(
self->parser);
self->last_col = (unsigned long)XML_GetCurrentColumnNumber(
self->parser);
PyTuple_SET_ITEM(tuple, 3, make_pos(self));
self->queue[self->queue_write_idx++] = tuple;
} else {
PyErr_SetString(
PyExc_RuntimeError,
"XML queue overflow in xmlDecl. This most likely indicates an internal bug.");
}
}
/**
* Reports insufficient system resources while parsing and increments the
* resource error count.
*
* @param context the parsing context
*/
static void resource_error(ploader_context_t *plcontext) {
if (plcontext->resource_error_count == 0) {
cpi_errorf(plcontext->context,
N_("Insufficient system resources to parse plug-in descriptor content in %s, line %d, column %d."),
plcontext->file,
XML_GetCurrentLineNumber(plcontext->parser),
XML_GetCurrentColumnNumber(plcontext->parser) + 1);
}
plcontext->resource_error_count++;
}
static int reporterror (lxp_userdata *xpu) {
lua_State *L = xpu->L;
XML_Parser p = xpu->parser;
lua_pushnil(L);
lua_pushstring(L, XML_ErrorString(XML_GetErrorCode(p)));
lua_pushnumber(L, XML_GetCurrentLineNumber(p));
lua_pushnumber(L, XML_GetCurrentColumnNumber(p) + 1);
lua_pushnumber(L, XML_GetCurrentByteIndex(p) + 1);
return 5;
}
static void XMLCALL
end_element_event_handler2(void *userData, const XML_Char *name)
{
CharData *storage = (CharData *) userData;
char buffer[100];
sprintf(buffer, "</%s> at col:%d line:%d\n", name,
XML_GetCurrentColumnNumber(parser),
XML_GetCurrentLineNumber(parser));
CharData_AppendString(storage, buffer);
}
OGRFeature *OGRJMLLayer::GetNextFeature()
{
if (!bHasReadSchema)
LoadSchema();
if (bStopParsing)
return nullptr;
if (nFeatureTabIndex < nFeatureTabLength)
{
return ppoFeatureTab[nFeatureTabIndex++];
}
if (VSIFEofL(fp))
return nullptr;
char aBuf[BUFSIZ];
nFeatureTabLength = 0;
nFeatureTabIndex = 0;
nWithoutEventCounter = 0;
int nDone = 0;
do
{
nDataHandlerCounter = 0;
unsigned int nLen =
(unsigned int)VSIFReadL( aBuf, 1, sizeof(aBuf), fp );
nDone = VSIFEofL(fp);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of JML file failed : %s "
"at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
(int)XML_GetCurrentLineNumber(oParser),
(int)XML_GetCurrentColumnNumber(oParser));
bStopParsing = true;
}
nWithoutEventCounter ++;
} while (!nDone && !bStopParsing && nFeatureTabLength == 0 &&
nWithoutEventCounter < 10);
if (nWithoutEventCounter == 10)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Too much data inside one element. File probably corrupted");
bStopParsing = true;
}
return (nFeatureTabLength) ? ppoFeatureTab[nFeatureTabIndex++] : nullptr;
}
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(); }
}
/* Generate a failure using the parser state to create an error message;
this should be used when the parser reports an error we weren't
expecting.
*/
static void
_xml_failure(XML_Parser parser, const char *file, int line)
{
char buffer[1024];
sprintf(buffer,
"\n %s (line %d, offset %d)\n reported from %s, line %d",
XML_ErrorString(XML_GetErrorCode(parser)),
XML_GetCurrentLineNumber(parser),
XML_GetCurrentColumnNumber(parser),
file, line);
_fail_unless(0, file, line, buffer);
}
wxString WrapExpat::getLastError()
{
if ( !p )
return _ ( "Unable to create parser instance" );
stringstream ss;
ss << "Error at line ";
ss << XML_GetCurrentLineNumber ( p );
ss << ", column " << XML_GetCurrentColumnNumber ( p ) + 1 << ":" << endl;
ss << XML_ErrorString ( XML_GetErrorCode ( p ) );
return wxString ( ss.str().c_str(), wxConvUTF8 );
}
static void
caldav_err(struct parse *p, const char *fmt, ...)
{
va_list ap;
fprintf(stderr, "%zu:%zu: ",
XML_GetCurrentLineNumber(p->xp),
XML_GetCurrentColumnNumber(p->xp));
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "\n");
XML_StopParser(p->xp, 0);
}
/* Generate a failure using the parser state to create an error message;
this should be used when the parser reports an error we weren't
expecting.
*/
static void
_xml_failure(XML_Parser parser, const char *file, int line)
{
char buffer[1024];
enum XML_Error err = XML_GetErrorCode(parser);
sprintf(buffer,
" %d: %s (line %" XML_FMT_INT_MOD "u, offset %"\
XML_FMT_INT_MOD "u)\n reported from %s, line %d\n",
err,
XML_ErrorString(err),
XML_GetCurrentLineNumber(parser),
XML_GetCurrentColumnNumber(parser),
file, line);
_fail_unless(0, file, line, buffer);
}
static void addToStack(Stack* stack, XML_Parser parser, std::unique_ptr<Node> node) {
node->lineNumber = XML_GetCurrentLineNumber(parser);
node->columnNumber = XML_GetCurrentColumnNumber(parser);
Node* thisNode = node.get();
if (!stack->nodeStack.empty()) {
stack->nodeStack.top()->addChild(std::move(node));
} else {
stack->root = std::move(node);
}
if (thisNode->type != NodeType::kText) {
stack->nodeStack.push(thisNode);
}
}
const wchar_t*
OMXMLReaderExpat::getPositionString()
{
TRACE("OMXMLReaderExpat::getPositionString");
int lineNumber = XML_GetCurrentLineNumber(_parser);
int columnNumber = XML_GetCurrentColumnNumber(_parser);
wchar_t buffer[30];
std_swprintf(buffer, 30, L"line %d, column %d", lineNumber, columnNumber);
_positionString = buffer;
return _positionString.c_str();
}
//=============================================================================
bool CPdpManager::LoadFromXml(const string& fromFile )
{
//read the file into a buffer
ifstream fProj(fromFile.c_str());
if (!fProj.is_open())
return false;
fProj.seekg( 0, ios_base::end );
std::streamoff fileSize = fProj.tellg();
if (fileSize <= 0)
return false;
fProj.seekg( 0, ios_base::beg);
vector<char> fileBuff;
fileBuff.resize(fileSize);
fProj.read(&(fileBuff[0]), fileSize);
fProj.close();
//parse the file's xml
XML_Parser m_parser;
m_parser = XML_ParserCreate(0);
XML_SetUserData(m_parser, this);
XML_SetStartElementHandler(m_parser, StartElement);
XML_SetEndElementHandler(m_parser, EndElement);
// XML_SetCharacterDataHandler(m_parser, CharacterDataHandler);
// XML_SetCommentHandler(m_parser, CommentHandler);
int rtn = XML_Parse(m_parser, &(fileBuff[0]), fileBuff.size(), true);
if (!rtn)
{
dprintf("Error parsing:\n");
dprintf(XML_ErrorString(XML_GetErrorCode(m_parser)));
dprintf(" (line: %d, col: %d)\n", XML_GetCurrentLineNumber(m_parser), XML_GetCurrentColumnNumber(m_parser));
}
// XML_SetCommentHandler(m_parser, 0);
// XML_SetCharacterDataHandler(m_parser, 0);
// XML_SetEndElementHandler(m_parser, 0);
XML_SetStartElementHandler(m_parser, 0);
XML_SetUserData(m_parser, 0);
XML_ParserFree(m_parser);
return (rtn == 0);
}
void XMLCALL XmlShallowValidator::skippedentity (
void *data,
const XML_Char *entityName,
int is_parameter_entity )
{
if ( is_parameter_entity )
return;
XmlShallowValidatorData *vd = ( XmlShallowValidatorData * ) data;
wxString entity ( entityName, wxConvUTF8 );
if ( vd->entitySet.find ( entity ) != vd->entitySet.end() )
return;
vd->isValid = false;
vd->positionVector.push_back (
make_pair ( XML_GetCurrentLineNumber ( vd->p ), XML_GetCurrentColumnNumber ( vd->p ) ) );
}
END_TEST
static void XMLCALL
start_element_event_handler2(void *userData, const XML_Char *name,
const XML_Char **attr)
{
CharData *storage = (CharData *) userData;
char buffer[100];
sprintf(buffer,
"<%s> at col:%" XML_FMT_INT_MOD "u line:%"\
XML_FMT_INT_MOD "u\n", name,
XML_GetCurrentColumnNumber(parser),
XML_GetCurrentLineNumber(parser));
CharData_AppendString(storage, buffer);
}
bool_t audit_parser(parser_t *parser) {
/* since a parser is used by nearly all xml-coreutils,
and the do_parser() functions call audit_parser(),
this is a great place to process signals */
process_pending_signal();
if( parser ) {
parser->cur.pstatus = get_pstatus(parser);
parser->cur.lineno = XML_GetCurrentLineNumber(parser->p);
parser->cur.colno = XML_GetCurrentColumnNumber(parser->p);
parser->cur.length = XML_GetCurrentByteCount(parser->p);
parser->cur.byteno = XML_GetCurrentByteIndex(parser->p);
return (bool_t)(parser->cur.rstatus == XML_STATUS_OK);
}
return FALSE;
}
void OGRVFPLayer::LoadSchema()
{
oSchemaParser = OGRCreateExpatXMLParser();
XML_SetElementHandler(oSchemaParser, ::startElementLoadSchemaCbk, ::endElementLoadSchemaCbk);
XML_SetCharacterDataHandler(oSchemaParser, ::dataHandlerLoadSchemaCbk);
XML_SetUserData(oSchemaParser, this);
VSIFSeekL( fpVFP, 0, SEEK_SET );
bStopParsing = FALSE;
nWithoutEventCounter = 0;
interestingDepthLevel = depthLevel = 0;
inInterestingElement = FALSE;
char aBuf[BUFSIZ];
int nDone;
do
{
nDataHandlerCounter = 0;
unsigned int nLen = (unsigned int)VSIFReadL( aBuf, 1, sizeof(aBuf), fpVFP );
nDone = VSIFEofL(fpVFP);
if (XML_Parse(oSchemaParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of GPX file failed : %s at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oSchemaParser)),
(int)XML_GetCurrentLineNumber(oSchemaParser),
(int)XML_GetCurrentColumnNumber(oSchemaParser));
bStopParsing = TRUE;
break;
}
nWithoutEventCounter ++;
} while (!nDone && !bStopParsing && nWithoutEventCounter < 10);
if (nWithoutEventCounter == 10)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Too much data inside one element. File probably corrupted");
bStopParsing = TRUE;
}
XML_ParserFree(oSchemaParser);
oSchemaParser = NULL;
VSIFSeekL( fpVFP, 0, SEEK_SET );
}
