void OGRJMLLayer::ResetReading()
{
nNextFID = 0;
VSIFSeekL( fp, 0, SEEK_SET );
if (oParser)
XML_ParserFree(oParser);
oParser = OGRCreateExpatXMLParser();
XML_SetElementHandler(oParser, ::startElementCbk, ::endElementCbk);
XML_SetCharacterDataHandler(oParser, ::dataHandlerCbk);
XML_SetUserData(oParser, this);
for( int i=nFeatureTabIndex; i<nFeatureTabLength; i++ )
delete ppoFeatureTab[i];
nFeatureTabIndex = 0;
nFeatureTabLength = 0;
delete poFeature;
poFeature = nullptr;
currentDepth = 0;
nCollectionElementDepth = 0;
nFeatureElementDepth = 0;
nGeometryElementDepth = 0;
nAttributeElementDepth = 0;
iAttr = -1;
bAccumulateElementValue = false;
nElementValueLen = 0;
pszElementValue[0] = '\0';
}
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");
}
}
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 );
}
void OGRSVGLayer::ResetReading()
{
nNextFID = 0;
if (fpSVG)
{
VSIFSeekL( fpSVG, 0, SEEK_SET );
#ifdef HAVE_EXPAT
if (oParser)
XML_ParserFree(oParser);
oParser = OGRCreateExpatXMLParser();
XML_SetElementHandler(oParser, ::startElementCbk, ::endElementCbk);
XML_SetCharacterDataHandler(oParser, ::dataHandlerCbk);
XML_SetUserData(oParser, this);
#endif
}
CPLFree(pszSubElementValue);
pszSubElementValue = NULL;
nSubElementValueLen = 0;
iCurrentField = -1;
int i;
for(i=nFeatureTabIndex;i<nFeatureTabLength;i++)
delete ppoFeatureTab[i];
CPLFree(ppoFeatureTab);
nFeatureTabIndex = 0;
nFeatureTabLength = 0;
ppoFeatureTab = NULL;
if (poFeature)
delete poFeature;
poFeature = NULL;
depthLevel = 0;
interestingDepthLevel = 0;
inInterestingElement = FALSE;
}
int GMLReader::SetupParser()
{
#if HAVE_XERCES == 1
if( !m_bXercesInitialized )
{
try
{
XMLPlatformUtils::Initialize();
}
catch (const XMLException& toCatch)
{
CPLError( CE_Warning, CPLE_AppDefined,
"Exception initializing Xerces based GML reader.\n%s",
tr_strdup(toCatch.getMessage()) );
return FALSE;
}
m_bXercesInitialized = TRUE;
}
// Cleanup any old parser.
if( m_poSAXReader != NULL )
CleanupParser();
// Create and initialize parser.
XMLCh* xmlUriValid = NULL;
XMLCh* xmlUriNS = NULL;
try{
m_poSAXReader = XMLReaderFactory::createXMLReader();
m_poGMLHandler = new GMLXercesHandler( this );
m_poSAXReader->setContentHandler( m_poGMLHandler );
m_poSAXReader->setErrorHandler( m_poGMLHandler );
m_poSAXReader->setLexicalHandler( m_poGMLHandler );
m_poSAXReader->setEntityResolver( m_poGMLHandler );
m_poSAXReader->setDTDHandler( m_poGMLHandler );
xmlUriValid = XMLString::transcode("http://xml.org/sax/features/validation");
xmlUriNS = XMLString::transcode("http://xml.org/sax/features/namespaces");
#if (OGR_GML_VALIDATION)
m_poSAXReader->setFeature( xmlUriValid, true);
m_poSAXReader->setFeature( xmlUriNS, true);
m_poSAXReader->setFeature( XMLUni::fgSAX2CoreNameSpaces, true );
m_poSAXReader->setFeature( XMLUni::fgXercesSchema, true );
// m_poSAXReader->setDoSchema(true);
// m_poSAXReader->setValidationSchemaFullChecking(true);
#else
m_poSAXReader->setFeature( XMLUni::fgSAX2CoreValidation, false);
#if XERCES_VERSION_MAJOR >= 3
m_poSAXReader->setFeature( XMLUni::fgXercesSchema, false);
#else
m_poSAXReader->setFeature( XMLUni::fgSAX2CoreNameSpaces, false);
#endif
#endif
XMLString::release( &xmlUriValid );
XMLString::release( &xmlUriNS );
}
catch (...)
{
XMLString::release( &xmlUriValid );
XMLString::release( &xmlUriNS );
CPLError( CE_Warning, CPLE_AppDefined,
"Exception initializing Xerces based GML reader.\n" );
return FALSE;
}
#else
// Cleanup any old parser.
if( oParser != NULL )
CleanupParser();
oParser = OGRCreateExpatXMLParser();
m_poGMLHandler = new GMLExpatHandler( this, oParser );
XML_SetElementHandler(oParser, ::startElementCbk, ::endElementCbk);
XML_SetCharacterDataHandler(oParser, ::dataHandlerCbk);
XML_SetUserData(oParser, m_poGMLHandler);
if (fpGML != NULL)
VSIFSeekL( fpGML, 0, SEEK_SET );
#endif
m_bReadStarted = FALSE;
// Push an empty state.
PushState( new GMLReadState() );
return TRUE;
}
int OGRGPXDataSource::Open( const char * pszFilename, int bUpdateIn)
{
if (bUpdateIn)
{
CPLError(CE_Failure, CPLE_NotSupported,
"OGR/GPX driver does not support opening a file in update mode");
return FALSE;
}
#ifdef HAVE_EXPAT
pszName = CPLStrdup( pszFilename );
/* -------------------------------------------------------------------- */
/* Try to open the file. */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(pszFilename, "r");
if (fp == NULL)
return FALSE;
validity = GPX_VALIDITY_UNKNOWN;
CPLFree(pszVersion);
pszVersion = NULL;
bUseExtensions = FALSE;
nElementsRead = 0;
XML_Parser oParser = OGRCreateExpatXMLParser();
oCurrentParser = oParser;
XML_SetUserData(oParser, this);
XML_SetElementHandler(oParser, ::startElementValidateCbk, NULL);
XML_SetCharacterDataHandler(oParser, ::dataHandlerValidateCbk);
char aBuf[BUFSIZ];
int nDone;
unsigned int nLen;
int nCount = 0;
/* Begin to parse the file and look for the <gpx> element */
/* It *MUST* be the first element of an XML file */
/* So once we have read the first element, we know if we can */
/* handle the file or not with that driver */
do
{
nDataHandlerCounter = 0;
nLen = (unsigned int) VSIFReadL( aBuf, 1, sizeof(aBuf), fp );
nDone = VSIFEofL(fp);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
if (nLen <= BUFSIZ-1)
aBuf[nLen] = 0;
else
aBuf[BUFSIZ-1] = 0;
if (strstr(aBuf, "<?xml") && strstr(aBuf, "<gpx"))
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of GPX file failed : %s at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
(int)XML_GetCurrentLineNumber(oParser),
(int)XML_GetCurrentColumnNumber(oParser));
}
validity = GPX_VALIDITY_INVALID;
break;
}
if (validity == GPX_VALIDITY_INVALID)
{
break;
}
else if (validity == GPX_VALIDITY_VALID)
{
/* If we have recognized the <gpx> element, now we try */
/* to recognize if they are <extensions> tags */
/* But we stop to look for after an arbitrary number of tags */
if (bUseExtensions)
break;
else if (nElementsRead > 200)
break;
}
else
{
/* After reading 50 * BUFSIZE bytes, and not finding whether the file */
/* is GPX or not, we give up and fail silently */
nCount ++;
if (nCount == 50)
break;
}
} while (!nDone && nLen > 0 );
XML_ParserFree(oParser);
VSIFCloseL(fp);
if (validity == GPX_VALIDITY_VALID)
{
CPLDebug("GPX", "%s seems to be a GPX file.", pszFilename);
if (bUseExtensions)
CPLDebug("GPX", "It uses <extensions>");
if (pszVersion == NULL)
{
/* Default to 1.1 */
CPLError(CE_Warning, CPLE_AppDefined, "GPX schema version is unknown. "
"The driver may not be able to handle the file correctly and will behave as if it is GPX 1.1.");
pszVersion = CPLStrdup("1.1");
}
else if (strcmp(pszVersion, "1.0") == 0 || strcmp(pszVersion, "1.1") == 0)
{
/* Fine */
}
else
{
CPLError(CE_Warning, CPLE_AppDefined,
"GPX schema version '%s' is not handled by the driver. "
"The driver may not be able to handle the file correctly and will behave as if it is GPX 1.1.", pszVersion);
}
nLayers = 5;
papoLayers = (OGRGPXLayer **) CPLRealloc(papoLayers, nLayers * sizeof(OGRGPXLayer*));
papoLayers[0] = new OGRGPXLayer( pszName, "waypoints", GPX_WPT, this, FALSE );
papoLayers[1] = new OGRGPXLayer( pszName, "routes", GPX_ROUTE, this, FALSE );
papoLayers[2] = new OGRGPXLayer( pszName, "tracks", GPX_TRACK, this, FALSE );
papoLayers[3] = new OGRGPXLayer( pszName, "route_points", GPX_ROUTE_POINT, this, FALSE );
papoLayers[4] = new OGRGPXLayer( pszName, "track_points", GPX_TRACK_POINT, this, FALSE );
}
return (validity == GPX_VALIDITY_VALID);
#else
char aBuf[256];
VSILFILE* fp = VSIFOpenL(pszFilename, "r");
if (fp)
{
unsigned int nLen = (unsigned int)VSIFReadL( aBuf, 1, 255, fp );
aBuf[nLen] = 0;
if (strstr(aBuf, "<?xml") && strstr(aBuf, "<gpx"))
{
CPLError(CE_Failure, CPLE_NotSupported,
"OGR/GPX driver has not been built with read support. Expat library required");
}
VSIFCloseL(fp);
}
return FALSE;
#endif
}
int OGRSVGDataSource::Open( const char * pszFilename, int bUpdateIn)
{
if (bUpdateIn)
{
CPLError(CE_Failure, CPLE_NotSupported,
"OGR/SVG driver does not support opening a file in update mode");
return FALSE;
}
#ifdef HAVE_EXPAT
pszName = CPLStrdup( pszFilename );
/* -------------------------------------------------------------------- */
/* Try to open the file. */
/* -------------------------------------------------------------------- */
CPLString osFilename(pszFilename);
if (EQUAL(CPLGetExtension(pszFilename), "svgz") &&
strstr(pszFilename, "/vsigzip/") == NULL)
{
osFilename = CPLString("/vsigzip/") + pszFilename;
pszFilename = osFilename.c_str();
}
VSILFILE* fp = VSIFOpenL(pszFilename, "r");
if (fp == NULL)
return FALSE;
eValidity = SVG_VALIDITY_UNKNOWN;
XML_Parser oParser = OGRCreateExpatXMLParser();
oCurrentParser = oParser;
XML_SetUserData(oParser, this);
XML_SetElementHandler(oParser, ::startElementValidateCbk, NULL);
XML_SetCharacterDataHandler(oParser, ::dataHandlerValidateCbk);
char aBuf[BUFSIZ];
int nDone;
unsigned int nLen;
int nCount = 0;
/* Begin to parse the file and look for the <svg> element */
/* It *MUST* be the first element of an XML file */
/* So once we have read the first element, we know if we can */
/* handle the file or not with that driver */
do
{
nDataHandlerCounter = 0;
nLen = (unsigned int) VSIFReadL( aBuf, 1, sizeof(aBuf), fp );
nDone = VSIFEofL(fp);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
if (nLen <= BUFSIZ-1)
aBuf[nLen] = 0;
else
aBuf[BUFSIZ-1] = 0;
if (strstr(aBuf, "<?xml") && strstr(aBuf, "<svg"))
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of SVG file failed : %s at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
(int)XML_GetCurrentLineNumber(oParser),
(int)XML_GetCurrentColumnNumber(oParser));
}
eValidity = SVG_VALIDITY_INVALID;
break;
}
if (eValidity == SVG_VALIDITY_INVALID)
{
break;
}
else if (eValidity == SVG_VALIDITY_VALID)
{
break;
}
else
{
/* After reading 50 * BUFSIZE bytes, and not finding whether the file */
/* is SVG or not, we give up and fail silently */
nCount ++;
if (nCount == 50)
break;
}
} while (!nDone && nLen > 0 );
XML_ParserFree(oParser);
VSIFCloseL(fp);
if (eValidity == SVG_VALIDITY_VALID)
{
if (bIsCloudmade)
{
nLayers = 3;
papoLayers =(OGRSVGLayer **) CPLRealloc(papoLayers,
nLayers * sizeof(OGRSVGLayer*));
papoLayers[0] = new OGRSVGLayer( pszFilename, "points", SVG_POINTS, this );
papoLayers[1] = new OGRSVGLayer( pszFilename, "lines", SVG_LINES, this );
papoLayers[2] = new OGRSVGLayer( pszFilename, "polygons", SVG_POLYGONS, this );
}
else
{
CPLDebug("SVG",
"%s seems to be a SVG file, but not a Cloudmade vector one.",
pszFilename);
}
}
return (nLayers > 0);
#else
char aBuf[256];
VSILFILE* fp = VSIFOpenL(pszFilename, "r");
if (fp)
{
unsigned int nLen = (unsigned int)VSIFReadL( aBuf, 1, 255, fp );
aBuf[nLen] = 0;
if (strstr(aBuf, "<?xml") && strstr(aBuf, "<svg") &&
strstr(aBuf, "http://cloudmade.com/"))
{
CPLError(CE_Failure, CPLE_NotSupported,
"OGR/SVG driver has not been built with read support. "
"Expat library required");
}
VSIFCloseL(fp);
}
return FALSE;
#endif
}
int OGRGeoRSSDataSource::Open( const char * pszFilename, int bUpdateIn)
{
if (bUpdateIn)
{
CPLError(CE_Failure, CPLE_NotSupported,
"OGR/GeoRSS driver does not support opening a file in update mode");
return FALSE;
}
#ifdef HAVE_EXPAT
pszName = CPLStrdup( pszFilename );
/* -------------------------------------------------------------------- */
/* Try to open the file. */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(pszFilename, "r");
if (fp == NULL)
return FALSE;
validity = GEORSS_VALIDITY_UNKNOWN;
XML_Parser oParser = OGRCreateExpatXMLParser();
XML_SetUserData(oParser, this);
XML_SetElementHandler(oParser, ::startElementValidateCbk, NULL);
XML_SetCharacterDataHandler(oParser, ::dataHandlerValidateCbk);
oCurrentParser = oParser;
char aBuf[BUFSIZ];
int nDone;
unsigned int nLen;
int nCount = 0;
/* Begin to parse the file and look for the <rss> or <feed> element */
/* It *MUST* be the first element of an XML file */
/* So once we have read the first element, we know if we can */
/* handle the file or not with that driver */
do
{
nDataHandlerCounter = 0;
nLen = (unsigned int) VSIFReadL( aBuf, 1, sizeof(aBuf), fp );
nDone = VSIFEofL(fp);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
if (nLen <= BUFSIZ-1)
aBuf[nLen] = 0;
else
aBuf[BUFSIZ-1] = 0;
if (strstr(aBuf, "<?xml") && (strstr(aBuf, "<rss") || strstr(aBuf, "<feed") || strstr(aBuf, "<atom:feed")))
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of GeoRSS file failed : %s at line %d, column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
(int)XML_GetCurrentLineNumber(oParser),
(int)XML_GetCurrentColumnNumber(oParser));
}
validity = GEORSS_VALIDITY_INVALID;
break;
}
if (validity == GEORSS_VALIDITY_INVALID)
{
break;
}
else if (validity == GEORSS_VALIDITY_VALID)
{
break;
}
else
{
/* After reading 50 * BUFSIZ bytes, and not finding whether the file */
/* is GeoRSS or not, we give up and fail silently */
nCount ++;
if (nCount == 50)
break;
}
} while (!nDone && nLen > 0 );
XML_ParserFree(oParser);
VSIFCloseL(fp);
if (validity == GEORSS_VALIDITY_VALID)
{
CPLDebug("GeoRSS", "%s seems to be a GeoRSS file.", pszFilename);
nLayers = 1;
papoLayers = (OGRGeoRSSLayer **) CPLRealloc(papoLayers, nLayers * sizeof(OGRGeoRSSLayer*));
papoLayers[0] = new OGRGeoRSSLayer( pszName, "georss", this, NULL, FALSE );
}
return (validity == GEORSS_VALIDITY_VALID);
#else
char aBuf[256];
VSILFILE* fp = VSIFOpenL(pszFilename, "r");
if (fp)
{
unsigned int nLen = (unsigned int)VSIFReadL( aBuf, 1, 255, fp );
aBuf[nLen] = 0;
if (strstr(aBuf, "<?xml") && (strstr(aBuf, "<rss") || strstr(aBuf, "<atom:feed") || strstr(aBuf, "<feed")))
{
CPLError(CE_Failure, CPLE_NotSupported,
"OGR/GeoRSS driver has not been built with read support. Expat library required");
}
VSIFCloseL(fp);
}
return FALSE;
#endif
}
void KML::checkValidity()
{
std::size_t nDone = 0;
std::size_t nLen = 0;
char aBuf[BUFSIZ] = { 0 };
if(poTrunk_ != NULL)
{
delete poTrunk_;
poTrunk_ = NULL;
}
if(poCurrent_ != NULL)
{
delete poCurrent_;
poCurrent_ = NULL;
}
if(pKMLFile_ == NULL)
{
this->sError_ = "No file given";
return;
}
XML_Parser oParser = OGRCreateExpatXMLParser();
XML_SetUserData(oParser, this);
XML_SetElementHandler(oParser, startElementValidate, NULL);
XML_SetCharacterDataHandler(oParser, dataHandlerValidate);
int nCount = 0;
oCurrentParser = oParser;
/* Parses the file until we find the first element */
do
{
nDataHandlerCounter = 0;
nLen = (int)VSIFReadL( aBuf, 1, sizeof(aBuf), pKMLFile_ );
nDone = VSIFEofL(pKMLFile_);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
if (nLen <= BUFSIZ-1)
aBuf[nLen] = 0;
else
aBuf[BUFSIZ-1] = 0;
if (strstr(aBuf, "<?xml") && strstr(aBuf, "<kml"))
{
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));
}
validity = KML_VALIDITY_INVALID;
XML_ParserFree(oParser);
VSIRewindL(pKMLFile_);
return;
}
nCount ++;
/* After reading 50 * BUFSIZE bytes, and not finding whether the file */
/* is KML or not, we give up and fail silently */
} while (!nDone && nLen > 0 && validity == KML_VALIDITY_UNKNOWN && nCount < 50);
XML_ParserFree(oParser);
VSIRewindL(pKMLFile_);
poCurrent_ = NULL;
}
/** This function parses the whole file to build the schema */
void OGRSVGLayer::LoadSchema()
{
CPLAssert(poFeatureDefn == NULL);
for(int i=0;i<poDS->GetLayerCount();i++)
{
OGRSVGLayer* poLayer = (OGRSVGLayer*)poDS->GetLayer(i);
poLayer->poFeatureDefn = new OGRFeatureDefn( poLayer->osLayerName );
poLayer->poFeatureDefn->Reference();
poLayer->poFeatureDefn->SetGeomType(poLayer->GetGeomType());
poLayer->poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poLayer->poSRS);
}
oSchemaParser = OGRCreateExpatXMLParser();
XML_SetElementHandler(oSchemaParser, ::startElementLoadSchemaCbk,
::endElementLoadSchemaCbk);
XML_SetCharacterDataHandler(oSchemaParser, ::dataHandlerLoadSchemaCbk);
XML_SetUserData(oSchemaParser, this);
if (fpSVG == NULL)
return;
VSIFSeekL( fpSVG, 0, SEEK_SET );
inInterestingElement = FALSE;
depthLevel = 0;
nWithoutEventCounter = 0;
bStopParsing = FALSE;
char aBuf[BUFSIZ];
int nDone;
do
{
nDataHandlerCounter = 0;
unsigned int nLen =
(unsigned int)VSIFReadL( aBuf, 1, sizeof(aBuf), fpSVG );
nDone = VSIFEofL(fpSVG);
if (XML_Parse(oSchemaParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
CPLError(CE_Failure, CPLE_AppDefined,
"XML parsing of SVG 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 < 1000);
if (nWithoutEventCounter == 1000)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Too much data inside one element. File probably corrupted");
bStopParsing = TRUE;
}
XML_ParserFree(oSchemaParser);
oSchemaParser = NULL;
VSIFSeekL( fpSVG, 0, SEEK_SET );
}
/** This function parses the beginning of the file to detect the fields */
void OGRJMLLayer::LoadSchema()
{
if (bHasReadSchema)
return;
bHasReadSchema = true;
oParser = OGRCreateExpatXMLParser();
XML_SetElementHandler(oParser, ::startElementLoadSchemaCbk,
::endElementLoadSchemaCbk);
XML_SetCharacterDataHandler(oParser, ::dataHandlerCbk);
XML_SetUserData(oParser, this);
VSIFSeekL( fp, 0, SEEK_SET );
char aBuf[BUFSIZ];
int nDone = 0;
do
{
nDataHandlerCounter = 0;
const unsigned int nLen = static_cast<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)),
static_cast<int>(XML_GetCurrentLineNumber(oParser)),
static_cast<int>(XML_GetCurrentColumnNumber(oParser)) );
bStopParsing = true;
}
nWithoutEventCounter ++;
} while ( !nDone && !bStopParsing && !bSchemaFinished &&
nWithoutEventCounter < 10 );
XML_ParserFree(oParser);
oParser = nullptr;
if (nWithoutEventCounter == 10)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Too much data inside one element. File probably corrupted");
bStopParsing = true;
}
if( osCollectionElement.empty() || osFeatureElement.empty() ||
osGeometryElement.empty() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Missing CollectionElement, FeatureElement or "
"GeometryElement" );
bStopParsing = true;
}
if( !osSRSName.empty() )
{
if( osSRSName.find("http://www.opengis.net/gml/srs/epsg.xml#") == 0 )
{
OGRSpatialReference* poSRS = new OGRSpatialReference();
poSRS->importFromEPSG(atoi(osSRSName.substr(
strlen("http://www.opengis.net/gml/srs/epsg.xml#")).c_str()));
poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
poSRS->Release();
}
}
nJCSGMLInputTemplateDepth = 0;
nCollectionElementDepth = 0;
nFeatureCollectionDepth = 0;
nFeatureElementDepth = 0;
nGeometryElementDepth = 0;
nColumnDepth = 0;
nNameDepth = 0;
nTypeDepth = 0;
nAttributeElementDepth = 0;
ResetReading();
}
