自学教程：C++ CPLGetExtension函数代码示例

OGRDataSource *OGRWalkDriver::Open( const char * pszFilename, int bUpdate ){    if( EQUALN(pszFilename, "PGEO:", strlen("PGEO:")) )        return NULL;    if( EQUALN(pszFilename, "GEOMEDIA:", strlen("GEOMEDIA:")) )        return NULL;    if( !EQUALN(pszFilename,"WALK:", strlen("WALK:"))        && !EQUAL(CPLGetExtension(pszFilename), "MDB") )        return NULL;#ifndef WIN32    // Try to register MDB Tools driver    //    // ODBCINST.INI NOTE:    // This operation requires write access to odbcinst.ini file    // located in directory pointed by ODBCINISYS variable.    // Usually, it points to /etc, so non-root users can overwrite this    // setting ODBCINISYS with location they have write access to, e.g.:    // $ export ODBCINISYS=$HOME/etc    // $ touch $ODBCINISYS/odbcinst.ini    //    // See: http://www.unixodbc.org/internals.html    //    if ( !InstallMdbDriver() )    {        CPLError( CE_Warning, CPLE_AppDefined,                   "Unable to install MDB driver for ODBC, MDB access may not supported./n" );    }    else        CPLDebug( "Walk", "MDB Tools driver installed successfully!");#endif /* ndef WIN32 */    OGRWalkDataSource  *poDS = new OGRWalkDataSource();    if( !poDS->Open( pszFilename, bUpdate ) )    {        delete poDS;        return NULL;    }    else        return poDS;}

int ARGDataset::Identify( GDALOpenInfo *poOpenInfo ){    json_object * pJSONObject;    if (!EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "arg")) {        return FALSE;    }    pJSONObject = GetJsonObject(poOpenInfo->pszFilename);    if (pJSONObject == NULL) {        return FALSE;    }    json_object_put(pJSONObject);    pJSONObject = NULL;    return TRUE;}

std::vector<CPLString> GetOutputDriversFor(const char* pszDestFilename,                                           int nFlagRasterVector){    std::vector<CPLString> aoDriverList;    CPLString osExt = CPLGetExtension(pszDestFilename);    const int nDriverCount = GDALGetDriverCount();    for( int i = 0; i < nDriverCount; i++ )    {        GDALDriverH hDriver = GDALGetDriver(i);        if( (GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, nullptr ) != nullptr ||             GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY, nullptr ) != nullptr ) &&            (((nFlagRasterVector & GDAL_OF_RASTER) &&                GDALGetMetadataItem( hDriver, GDAL_DCAP_RASTER, nullptr ) != nullptr) ||            ((nFlagRasterVector & GDAL_OF_VECTOR) &&                GDALGetMetadataItem( hDriver, GDAL_DCAP_VECTOR, nullptr ) != nullptr)) )        {            if( !osExt.empty() && DoesDriverHandleExtension(hDriver, osExt) )            {                aoDriverList.push_back( GDALGetDriverShortName(hDriver) );            }            else            {                const char* pszPrefix = GDALGetMetadataItem(hDriver,                    GDAL_DMD_CONNECTION_PREFIX, nullptr);                if( pszPrefix && STARTS_WITH_CI(pszDestFilename, pszPrefix) )                {                    aoDriverList.push_back( GDALGetDriverShortName(hDriver) );                }            }        }    }    // GMT is registered before netCDF for opening reasons, but we want    // netCDF to be used by default for output.    if( EQUAL(osExt, "nc") && aoDriverList.size() == 2 &&        EQUAL(aoDriverList[0], "GMT") && EQUAL(aoDriverList[1], "NETCDF") )    {        aoDriverList.clear();        aoDriverList.push_back("NETCDF");        aoDriverList.push_back("GMT");    }    return aoDriverList;}

void CheckExtensionConsistency(const char* pszDestFilename,                               const char* pszDriverName){    char* pszDestExtension = CPLStrdup(CPLGetExtension(pszDestFilename));    if (pszDestExtension[0] != '/0')    {        int nDriverCount = GDALGetDriverCount();        CPLString osConflictingDriverList;        for(int i=0;i<nDriverCount;i++)        {            GDALDriverH hDriver = GDALGetDriver(i);            const char* pszDriverExtension =                 GDALGetMetadataItem( hDriver, GDAL_DMD_EXTENSION, NULL );               if (pszDriverExtension && EQUAL(pszDestExtension, pszDriverExtension))            {                if (GDALGetDriverByName(pszDriverName) != hDriver)                {                    if (osConflictingDriverList.size())                        osConflictingDriverList += ", ";                    osConflictingDriverList += GDALGetDriverShortName(hDriver);                }                else                {                    /* If the request driver allows the used extension, then */                    /* just stop iterating now */                    osConflictingDriverList = "";                    break;                }            }        }        if (osConflictingDriverList.size())        {            fprintf(stderr,                    "Warning: The target file has a '%s' extension, which is normally used by the %s driver%s,/n"                    "but the requested output driver is %s. Is it really what you want ?/n",                    pszDestExtension,                    osConflictingDriverList.c_str(),                    strchr(osConflictingDriverList.c_str(), ',') ? "s" : "",                    pszDriverName);        }    }    CPLFree(pszDestExtension);}

int RDataset::Identify( GDALOpenInfo *poOpenInfo ){    if( poOpenInfo->nHeaderBytes < 50 )        return FALSE;    // If the extension is .rda and the file type is gzip    // compressed we assume it is a gzipped R binary file.    if( memcmp(poOpenInfo->pabyHeader, "/037/213/b", 3) == 0 &&        EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "rda") )        return TRUE;    // Is this an ASCII or XDR binary R file?    if( !STARTS_WITH_CI((const char *)poOpenInfo->pabyHeader, "RDA2/nA/n") &&        !STARTS_WITH_CI((const char *)poOpenInfo->pabyHeader, "RDX2/nX/n") )        return FALSE;    return TRUE;}

int ARGDataset::Identify( GDALOpenInfo *poOpenInfo ){#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION    if (!EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "arg")) {        return FALSE;    }#endif    json_object *pJSONObject = GetJsonObject(poOpenInfo->pszFilename);    if (pJSONObject == nullptr) {        return FALSE;    }    json_object_put(pJSONObject);    pJSONObject = nullptr;    return TRUE;}

bool wxGISDataset::Rename(const wxString &sNewName, ITrackCancel* const pTrackCancel){	wxCriticalSectionLocker locker(m_CritSect);    Close();    CPLString szDirPath = CPLGetPath(m_sPath);    CPLString szName = CPLGetBasename(m_sPath);	CPLString szNewName(ClearExt(sNewName).mb_str(wxConvUTF8));    char** papszFileList = GetFileList();    papszFileList = CSLAddString( papszFileList, m_sPath );    if(!papszFileList)        {        if(pTrackCancel)            pTrackCancel->PutMessage(_("No files to rename"), wxNOT_FOUND, enumGISMessageErr);        return false;    }    char **papszNewFileList = NULL;    for(int i = 0; papszFileList[i] != NULL; ++i )    {        CPLString szNewPath(CPLFormFilename(szDirPath, szNewName, GetExtension(papszFileList[i], szName)));        papszNewFileList = CSLAddString(papszNewFileList, szNewPath);        if(!RenameFile(papszFileList[i], papszNewFileList[i], pTrackCancel))        {            // Try to put the ones we moved back.            for( --i; i >= 0; i-- )                RenameFile( papszNewFileList[i], papszFileList[i]); 			CSLDestroy( papszFileList );			CSLDestroy( papszNewFileList );            return false;        }    }	m_sPath = CPLString(CPLFormFilename(szDirPath, szNewName, CPLGetExtension(m_sPath)));	CSLDestroy( papszFileList );	CSLDestroy( papszNewFileList );	return true;}

OGRDataSource *OGRDWGDriver::Open( const char * pszFilename, int /*bUpdate*/ ){    if( !EQUAL(CPLGetExtension(pszFilename),"dwg") )        return NULL;    if( !OGRTEIGHAInitialize() )        return NULL;    OGRDWGDataSource   *poDS = new OGRDWGDataSource();    if( !poDS->Open( OGRDWGGetServices(), pszFilename ) )    {        delete poDS;        poDS = NULL;    }    return poDS;}

bool wxGxWebConnectionFactory::GetChildren(wxGxObject* pParent, char** &pFileNames, wxArrayLong & pChildrenIds){    wxGxCatalogBase* pCatalog = GetGxCatalog();    for(int i = CSLCount(pFileNames) - 1; i >= 0; i-- )    {        CPLString szExt = CPLGetExtension(pFileNames[i]);		if(wxGISEQUAL(szExt, "wconn"))		{            if( m_bHasDriver )            {    			wxGxObject* pObj = GetGxObject(pParent, GetConvName(pFileNames[i]), pFileNames[i]);                 if(pObj)                    pChildrenIds.Add(pObj->GetId());            }            pFileNames = CSLRemoveStrings( pFileNames, i, 1, NULL );		}    }	return true;}

int BAGDataset::Identify( GDALOpenInfo * poOpenInfo ){/* -------------------------------------------------------------------- *//*      Is it an HDF5 file?                                             *//* -------------------------------------------------------------------- */    static const char achSignature[] = "/211HDF/r/n/032/n";    if( poOpenInfo->pabyHeader == NULL        || memcmp(poOpenInfo->pabyHeader,achSignature,8) != 0 )        return FALSE;/* -------------------------------------------------------------------- *//*      Does it have the extension .bag?                                *//* -------------------------------------------------------------------- */    if( !EQUAL(CPLGetExtension(poOpenInfo->pszFilename),"bag") )        return FALSE;    return TRUE;}

static GDALDataset *OGRAeronavFAADriverOpen( GDALOpenInfo* poOpenInfo ){    if (poOpenInfo->eAccess == GA_Update ||        poOpenInfo->fpL == NULL ||        !EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "dat") )    {        return NULL;    }    OGRAeronavFAADataSource   *poDS = new OGRAeronavFAADataSource();    if( !poDS->Open( poOpenInfo->pszFilename ) )    {        delete poDS;        poDS = NULL;    }    return poDS;}

OGRDataSource *OGRPDFDriver::Open( const char * pszFilename, int bUpdate ){    if( !EQUAL(CPLGetExtension(pszFilename), "pdf") || bUpdate )        return NULL;/* -------------------------------------------------------------------- *//*      Try to create datasource.                                       *//* -------------------------------------------------------------------- */    OGRPDFDataSource     *poDS;    poDS = new OGRPDFDataSource();    if( !poDS->Open( pszFilename ) )    {        delete poDS;        return NULL;    }    else        return poDS;}

static int OGRGMLDriverIdentify( GDALOpenInfo* poOpenInfo ){    if( poOpenInfo->fpL == NULL )    {        if( strstr(poOpenInfo->pszFilename, "xsd=") != NULL )            return -1; /* must be later checked */        return FALSE;    }    /* Might be a OS-Mastermap gzipped GML, so let be nice and try to open */    /* it transparently with /vsigzip/ */    else    if ( poOpenInfo->pabyHeader[0] == 0x1f && poOpenInfo->pabyHeader[1] == 0x8b &&         EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "gz") &&         strncmp(poOpenInfo->pszFilename, "/vsigzip/", strlen("/vsigzip/")) != 0 )    {        return -1; /* must be later checked */    }    else    {        const char* szPtr = (const char*)poOpenInfo->pabyHeader;        if( ( (unsigned char)szPtr[0] == 0xEF )            && ( (unsigned char)szPtr[1] == 0xBB )            && ( (unsigned char)szPtr[2] == 0xBF) )        {            szPtr += 3;        }/* -------------------------------------------------------------------- *//*      Here, we expect the opening chevrons of GML tree root element   *//* -------------------------------------------------------------------- */        if( szPtr[0] != '<' )            return FALSE;        if( !poOpenInfo->TryToIngest(4096) )            return FALSE;        return OGRGMLDataSource::CheckHeader((const char*)poOpenInfo->pabyHeader);    }}

bool wxGxLocalDBFactory::GetChildren(wxGxObject* pParent, char** &pFileNames, wxArrayLong & pChildrenIds){    wxGxCatalogBase* pCatalog = GetGxCatalog();    bool bCheckNames = CSLCount(pFileNames) < CHECK_DUBLES_MAX_COUNT;    for(int i = CSLCount(pFileNames) - 1; i >= 0; i-- )    {        VSIStatBufL BufL;        int ret = VSIStatL(pFileNames[i], &BufL);        if(ret == 0)        {            if (VSI_ISDIR(BufL.st_mode) && wxGISEQUAL(CPLGetExtension(pFileNames[i]), "gdb"))            {                wxGxObject* pObj = GetGxObject(pParent, wxString(CPLGetFilename(pFileNames[i]), wxConvUTF8), pFileNames[i], enumContGDBFolder, bCheckNames);                if(pObj)                    pChildrenIds.Add(pObj->GetId());                pFileNames = CSLRemoveStrings( pFileNames, i, 1, NULL );            }            //TODO: mdb, sqlite, db extensions        }    }    return true;}

void CheckExtensionConsistency(const char* pszDestFilename,                               const char* pszDriverName){    CPLString osExt = CPLGetExtension(pszDestFilename);    if( !osExt.empty() )    {        GDALDriverH hThisDrv = GDALGetDriverByName(pszDriverName);        if( hThisDrv != NULL && DoesDriverHandleExtension(hThisDrv, osExt) )            return;        const int nDriverCount = GDALGetDriverCount();        CPLString osConflictingDriverList;        for( int i = 0; i < nDriverCount; i++ )        {            GDALDriverH hDriver = GDALGetDriver(i);            if( hDriver != hThisDrv &&                DoesDriverHandleExtension(hDriver, osExt) )            {                if (osConflictingDriverList.size())                    osConflictingDriverList += ", ";                osConflictingDriverList += GDALGetDriverShortName(hDriver);            }        }        if (osConflictingDriverList.size())        {            fprintf(                stderr,                "Warning: The target file has a '%s' extension, "                "which is normally used by the %s driver%s, "                "but the requested output driver is %s. "                "Is it really what you want?/n",                osExt.c_str(),                osConflictingDriverList.c_str(),                strchr(osConflictingDriverList.c_str(), ',') ? "s" : "",                pszDriverName);        }    }}

staticvoid CheckDestDataSourceNameConsistency(const char* pszDestFilename,                                        const char* pszDriverName){    int i;    char* pszDestExtension = CPLStrdup(CPLGetExtension(pszDestFilename));    if( EQUAL(pszDriverName, "GMT") )        pszDriverName = "OGR_GMT";    CheckExtensionConsistency(pszDestFilename, pszDriverName);    static const char* apszBeginName[][2] =  { { "PG:"      , "PostgreSQL" },                                               { "MySQL:"   , "MySQL" },                                               { "CouchDB:" , "CouchDB" },                                               { "GFT:"     , "GFT" },                                               { "MSSQL:"   , "MSSQLSpatial" },                                               { "ODBC:"    , "ODBC" },                                               { "OCI:"     , "OCI" },                                               { "SDE:"     , "SDE" },                                               { "WFS:"     , "WFS" },                                               { NULL, NULL }                                             };    for(i=0; apszBeginName[i][0] != NULL; i++)    {        if (EQUALN(pszDestFilename, apszBeginName[i][0], strlen(apszBeginName[i][0])) &&            !EQUAL(pszDriverName, apszBeginName[i][1]))        {            CPLError(CE_Warning, CPLE_AppDefined,                    "The target file has a name which is normally recognized by the %s driver,/n"                    "but the requested output driver is %s. Is it really what you want ?/n",                    apszBeginName[i][1],                    pszDriverName);            break;        }    }    CPLFree(pszDestExtension);}

int ROIPACDataset::Identify( GDALOpenInfo *poOpenInfo ){/* -------------------------------------------------------------------- *//*      Check if:                                                       *//*      * 1. The data file extension is known                           *//* -------------------------------------------------------------------- */    const char *pszExtension = CPLGetExtension(poOpenInfo->pszFilename);    if ( strcmp( pszExtension, "raw" ) == 0 )    {        /* Since gdal do not read natively CInt8, more work is needed         * to read raw files */        return false;    }    bool bExtensionIsValid = strcmp( pszExtension, "int" ) == 0                               || strcmp( pszExtension, "slc" ) == 0                               || strcmp( pszExtension, "amp" ) == 0                               || strcmp( pszExtension, "cor" ) == 0                               || strcmp( pszExtension, "hgt" ) == 0                               || strcmp( pszExtension, "unw" ) == 0                               || strcmp( pszExtension, "msk" ) == 0                               || strcmp( pszExtension, "trans" ) == 0                               || strcmp( pszExtension, "dem" ) == 0                               || strcmp( pszExtension, "flg" ) == 0;    if ( !bExtensionIsValid )    {        return false;    }/* -------------------------------------------------------------------- *//*      * 2. there is a .rsc file                                      *//* -------------------------------------------------------------------- */    CPLString osRscFilename = getRscFilename( poOpenInfo );    if ( osRscFilename.empty() )    {        return false;    }    return true;}

OGRDataSource *OGRXLSDriver::Open( const char * pszFilename, int bUpdate ){    if (bUpdate)    {        return NULL;    }    if (!EQUAL(CPLGetExtension(pszFilename), "XLS"))    {        return NULL;    }    OGRXLSDataSource   *poDS = new OGRXLSDataSource();    if( !poDS->Open( pszFilename, bUpdate ) )    {        delete poDS;        poDS = NULL;    }    return poDS;}

OGRDataSource *OGRXPlaneDriver::Open( const char * pszFilename, int bUpdate ){    if ( bUpdate )    {        return NULL;    }    if( !EQUAL(CPLGetExtension(pszFilename), "dat") )        return NULL;    OGRXPlaneDataSource   *poDS = new OGRXPlaneDataSource();    int bReadWholeFile = CSLTestBoolean(CPLGetConfigOption("OGR_XPLANE_READ_WHOLE_FILE", "TRUE"));    if( !poDS->Open( pszFilename, bReadWholeFile ) )    {        delete poDS;        poDS = NULL;    }    return poDS;}

OGRDataSource *OGRODBCDriver::Open( const char * pszFilename,                                     int bUpdate ){    OGRODBCDataSource     *poDS;    if( !EQUALN(pszFilename,"ODBC:",5) #ifdef WIN32        && !EQUAL(CPLGetExtension(pszFilename), "MDB")#endif        )        return NULL;    poDS = new OGRODBCDataSource();    if( !poDS->Open( pszFilename, bUpdate, TRUE ) )    {        delete poDS;        return NULL;    }    else        return poDS;}

OGRDataSource *OGRSXFDriver::Open( const char * pszFilename, int bUpdate ){/* -------------------------------------------------------------------- *//*      Determine what sort of object this is.                          *//* -------------------------------------------------------------------- */    VSIStatBufL sStatBuf;    if (!EQUAL(CPLGetExtension(pszFilename), "sxf") ||        VSIStatL(pszFilename, &sStatBuf) != 0 ||        !VSI_ISREG(sStatBuf.st_mode))        return FALSE;    OGRSXFDataSource   *poDS = new OGRSXFDataSource();    if( !poDS->Open( pszFilename, bUpdate ) )    {        delete poDS;        poDS = NULL;    }    return poDS;}

int RIKDataset::Identify( GDALOpenInfo * poOpenInfo ){    if( poOpenInfo->fpL == NULL || poOpenInfo->nHeaderBytes < 50 )        return FALSE;    if( EQUALN((const char *) poOpenInfo->pabyHeader, "RIK3", 4) )    {        return TRUE;    }    else    {        GUInt16 actLength;        memcpy(&actLength, poOpenInfo->pabyHeader, 2);#ifdef CPL_MSB        CPL_SWAP16PTR( &actLength );#endif        if( actLength + 2 > 1024 )        {            return FALSE;        }        if( actLength == 0 )            return -1;                for( int i=0;i<actLength;i++ )        {            if( poOpenInfo->pabyHeader[2+i] == 0 )                return FALSE;        }        if( EQUAL( CPLGetExtension(poOpenInfo->pszFilename), "rik") )            return TRUE;        // We really need Open to be able to conclude        return -1;    }}

OGRDataSource *OGRGeoconceptDriver::Open( const char* pszFilename,                                          int bUpdate ){#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION/* -------------------------------------------------------------------- *//*      We will only consider .gxt and .txt files.                      *//* -------------------------------------------------------------------- */    const char* pszExtension = CPLGetExtension(pszFilename);    if( !EQUAL(pszExtension,"gxt") && !EQUAL(pszExtension,"txt") )    {        return nullptr;    }#endif    OGRGeoconceptDataSource  *poDS = new OGRGeoconceptDataSource();    if( !poDS->Open( pszFilename, true, CPL_TO_BOOL(bUpdate) ) )    {        delete poDS;        return nullptr;    }    return poDS;}

OGRDataSource *OGRIdrisiDriver::Open( const char * pszFilename, int bUpdate ){    if (bUpdate)    {        return NULL;    }// --------------------------------------------------------------------//      Does this appear to be a .vct file?// --------------------------------------------------------------------    if ( !EQUAL(CPLGetExtension(pszFilename), "vct") )        return NULL;    OGRIdrisiDataSource *poDS = new OGRIdrisiDataSource();    if( !poDS->Open( pszFilename ) )    {        delete poDS;        poDS = NULL;    }    return poDS;}

OGRDataSource *OGRGeoconceptDriver::Open( const char* pszFilename,                                          int bUpdate ){    OGRGeoconceptDataSource  *poDS;/* -------------------------------------------------------------------- *//*      We will only consider .gxt and .txt files.                      *//* -------------------------------------------------------------------- */    const char* pszExtension = CPLGetExtension(pszFilename);    if( !EQUAL(pszExtension,"gxt") && !EQUAL(pszExtension,"txt") )    {        return NULL;    }    poDS = new OGRGeoconceptDataSource();    if( !poDS->Open( pszFilename, TRUE, bUpdate ) )    {        delete poDS;        return NULL;    }    return poDS;}

int OGRTABDataSource::Create( const char * pszName, char **papszOptions ){    CPLAssert(m_pszName == nullptr);    m_pszName = CPLStrdup(pszName);    m_papszOptions = CSLDuplicate(papszOptions);    m_bUpdate = TRUE;    const char *pszOpt = CSLFetchNameValue(papszOptions, "FORMAT");    if( pszOpt != nullptr && EQUAL(pszOpt, "MIF") )        m_bCreateMIF = TRUE;    else if( EQUAL(CPLGetExtension(pszName),"mif") ||             EQUAL(CPLGetExtension(pszName),"mid") )        m_bCreateMIF = TRUE;    if( (pszOpt = CSLFetchNameValue(papszOptions,"SPATIAL_INDEX_MODE")) != nullptr )    {        if( EQUAL(pszOpt, "QUICK") )            m_bQuickSpatialIndexMode = TRUE;        else if( EQUAL(pszOpt, "OPTIMIZED") )            m_bQuickSpatialIndexMode = FALSE;    }    m_nBlockSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKSIZE", "512"));    // Create a new empty directory.    VSIStatBufL sStat;    if( strlen(CPLGetExtension(pszName)) == 0 )    {        if( VSIStatL( pszName, &sStat ) == 0 )        {            if( !VSI_ISDIR(sStat.st_mode) )            {                CPLError(CE_Failure, CPLE_OpenFailed,                         "Attempt to create dataset named %s,/n"                         "but that is an existing file.",                         pszName);                return FALSE;            }        }        else        {            if( VSIMkdir(pszName, 0755) != 0 )            {                CPLError(CE_Failure, CPLE_AppDefined,                         "Unable to create directory %s.",                         pszName);                return FALSE;            }        }        m_pszDirectory = CPLStrdup(pszName);    }    // Create a new single file.    else    {        IMapInfoFile *poFile = nullptr;        const char *pszEncoding( CSLFetchNameValue( papszOptions, "ENCODING" ) );        const char *pszCharset( IMapInfoFile::EncodingToCharset( pszEncoding ) );        if( m_bCreateMIF )        {            poFile = new MIFFile;            if( poFile->Open(m_pszName, TABWrite, FALSE, pszCharset) != 0 )            {                delete poFile;                return FALSE;            }        }        else        {            TABFile *poTabFile = new TABFile;            if( poTabFile->Open(m_pszName, TABWrite, FALSE,                                m_nBlockSize, pszCharset) != 0 )            {                delete poTabFile;                return FALSE;            }            poFile = poTabFile;        }        m_nLayerCount = 1;        m_papoLayers = static_cast<IMapInfoFile **>(CPLMalloc(sizeof(void *)));        m_papoLayers[0] = poFile;        m_pszDirectory = CPLStrdup(CPLGetPath(pszName));        m_bSingleFile = TRUE;    }    return TRUE;}

static bool OGRGPSBabelDriverIdentifyInternal(    GDALOpenInfo* poOpenInfo,    const char** ppszGSPBabelDriverName ){    if( STARTS_WITH_CI(poOpenInfo->pszFilename, "GPSBABEL:") )        return true;    const char* pszGPSBabelDriverName = NULL;    if( poOpenInfo->fpL == NULL )            return false;    if (memcmp(poOpenInfo->pabyHeader, "MsRcd", 5) == 0)        pszGPSBabelDriverName = "mapsource";    else if (memcmp(poOpenInfo->pabyHeader, "MsRcf", 5) == 0)        pszGPSBabelDriverName = "gdb";    else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "<osm") != NULL)        pszGPSBabelDriverName = "osm";    else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$GPGSA") != NULL ||                strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$GPGGA") != NULL)        pszGPSBabelDriverName = "nmea";    else if (STARTS_WITH_CI((const char*)poOpenInfo->pabyHeader, "OziExplorer"))        pszGPSBabelDriverName = "ozi";    else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "Grid") &&                strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "Datum") &&                strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "Header"))        pszGPSBabelDriverName = "garmin_txt";    else if (poOpenInfo->pabyHeader[0] == 13 && poOpenInfo->pabyHeader[10] == 'M' && poOpenInfo->pabyHeader[11] == 'S' &&                (poOpenInfo->pabyHeader[12] >= '0' && poOpenInfo->pabyHeader[12] <= '9') &&                (poOpenInfo->pabyHeader[13] >= '0' && poOpenInfo->pabyHeader[13] <= '9') &&                poOpenInfo->pabyHeader[12] * 10 + poOpenInfo->pabyHeader[13] >= 30 &&                (poOpenInfo->pabyHeader[14] == 1 || poOpenInfo->pabyHeader[14] == 2) && poOpenInfo->pabyHeader[15] == 0 &&                poOpenInfo->pabyHeader[16] == 0 && poOpenInfo->pabyHeader[17] == 0)        pszGPSBabelDriverName = "mapsend";    else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$PMGNWPL") != NULL ||                strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$PMGNRTE") != NULL)        pszGPSBabelDriverName = "magellan";    else if (poOpenInfo->pabyHeader[0] == 'A' &&                poOpenInfo->pabyHeader[1] >= 'A' && poOpenInfo->pabyHeader[1] <= 'Z' &&                poOpenInfo->pabyHeader[2] >= 'A' && poOpenInfo->pabyHeader[2] <= 'Z' &&                poOpenInfo->pabyHeader[3] >= 'A' && poOpenInfo->pabyHeader[3] <= 'Z' &&                EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "igc") )        pszGPSBabelDriverName = "igc";    static int bGPSBabelFound = -1;    if( pszGPSBabelDriverName != NULL && bGPSBabelFound < 0 )    {#ifndef WIN32        VSIStatBufL sStat;        bGPSBabelFound = VSIStatL("/usr/bin/gpsbabel", &sStat) == 0;        if( !bGPSBabelFound )#endif        {            const char* const apszArgs[] = { "gpsbabel", "-V", NULL };            CPLString osTmpFileName("/vsimem/gpsbabel_tmp.tmp");            VSILFILE* tmpfp = VSIFOpenL(osTmpFileName, "wb");            bGPSBabelFound = (CPLSpawn(apszArgs, NULL, tmpfp, FALSE) == 0);            VSIFCloseL(tmpfp);            VSIUnlink(osTmpFileName);        }    }    if( bGPSBabelFound )        *ppszGSPBabelDriverName = pszGPSBabelDriverName;    return *ppszGSPBabelDriverName != NULL;}

OGRDataSource *OGRGeomediaDriver::Open( const char * pszFilename,                                    int bUpdate ){    OGRGeomediaDataSource     *poDS;    if( EQUALN(pszFilename, "WALK:", strlen("WALK:")) )        return NULL;    if( EQUALN(pszFilename, "PGEO:", strlen("PGEO:")) )        return NULL;    if( !EQUALN(pszFilename,"GEOMEDIA:",9)         && !EQUAL(CPLGetExtension(pszFilename),"mdb") )        return NULL;    /* Disabling the attempt to guess if a MDB file is a Geomedia database */    /* or not. See similar fix in PGeo driver for rationale. */#if 0    if( !EQUALN(pszFilename,"GEOMEDIA:",9) &&        EQUAL(CPLGetExtension(pszFilename),"mdb") )    {        VSILFILE* fp = VSIFOpenL(pszFilename, "rb");        if (!fp)            return NULL;        GByte* pabyHeader = (GByte*) CPLMalloc(100000);        VSIFReadL(pabyHeader, 100000, 1, fp);        VSIFCloseL(fp);        /* Look for GAliasTable table */        const GByte pabyNeedle[] = { 'G', 0, 'A', 0, 'l', 0, 'i', 0, 'a', 0, 's', 0, 'T', 0, 'a', 0, 'b', 0, 'l', 0, 'e'};        int bFound = FALSE;        for(int i=0;i<100000 - (int)sizeof(pabyNeedle);i++)        {            if (memcmp(pabyHeader + i, pabyNeedle, sizeof(pabyNeedle)) == 0)            {                bFound = TRUE;                break;            }        }        CPLFree(pabyHeader);        if (!bFound)            return NULL;    }#endif#ifndef WIN32    // Try to register MDB Tools driver    //    // ODBCINST.INI NOTE:    // This operation requires write access to odbcinst.ini file    // located in directory pointed by ODBCINISYS variable.    // Usually, it points to /etc, so non-root users can overwrite this    // setting ODBCINISYS with location they have write access to, e.g.:    // $ export ODBCINISYS=$HOME/etc    // $ touch $ODBCINISYS/odbcinst.ini    //    // See: http://www.unixodbc.org/internals.html    //    if ( !InstallMdbDriver() )    {        CPLError( CE_Warning, CPLE_AppDefined,                   "Unable to install MDB driver for ODBC, MDB access may not supported./n" );    }    else        CPLDebug( "Geomedia", "MDB Tools driver installed successfully!");#endif /* ndef WIN32 */    // Open data source    poDS = new OGRGeomediaDataSource();    if( !poDS->Open( pszFilename, bUpdate, TRUE ) )    {        delete poDS;        return NULL;    }    else        return poDS;}