void CPLEmergencyError( const char *pszMessage )
{
CPLErrorContext *psCtx = NULL;
static int bInEmergencyError = FALSE;
// If we are already in emergency error then one of the
// following failed, so avoid them the second time through.
if( !bInEmergencyError )
{
bInEmergencyError = TRUE;
psCtx = (CPLErrorContext *) CPLGetTLS( CTLS_ERRORCONTEXT );
if( psCtx != NULL && psCtx->psHandlerStack != NULL )
{
psCtx->psHandlerStack->pfnHandler( CE_Fatal, CPLE_AppDefined,
pszMessage );
}
else if( pfnErrorHandler != NULL )
{
pfnErrorHandler( CE_Fatal, CPLE_AppDefined, pszMessage );
}
}
// Ultimate fallback.
fprintf( stderr, "FATAL: %s\n", pszMessage );
abort();
}
void CPLEmergencyError( const char *pszMessage )
{
CPLErrorContext *psCtx = NULL;
static int bInEmergencyError = FALSE;
if( !bInEmergencyError )
{
bInEmergencyError = TRUE;
psCtx = (CPLErrorContext *) CPLGetTLS( CTLS_ERRORCONTEXT );
}
if( psCtx != NULL && psCtx->psHandlerStack != NULL )
{
psCtx->psHandlerStack->pfnHandler( CE_Fatal, CPLE_AppDefined,
pszMessage );
}
else if( pfnErrorHandler != NULL )
{
pfnErrorHandler( CE_Fatal, CPLE_AppDefined, pszMessage );
}
else
{
fprintf( stderr, "FATAL: %s\n", pszMessage );
}
abort();
}
static FindFileTLS* CPLGetFindFileTLS()
{
FindFileTLS* pTLSData =
(FindFileTLS *) CPLGetTLS( CTLS_FINDFILE );
if (pTLSData == NULL)
{
pTLSData = (FindFileTLS*) CPLCalloc(1, sizeof(FindFileTLS));
CPLSetTLSWithFreeFunc( CTLS_FINDFILE, pTLSData, CPLFindFileFreeTLS );
}
return pTLSData;
}
void CSVDeaccess( const char * pszFilename )
{
CSVTable **ppsCSVTableList;
/* -------------------------------------------------------------------- */
/* Fetch the table, and allocate the thread-local pointer to it */
/* if there isn't already one. */
/* -------------------------------------------------------------------- */
ppsCSVTableList = (CSVTable **) CPLGetTLS( CTLS_CSVTABLEPTR );
CSVDeaccessInternal(ppsCSVTableList, TRUE, pszFilename);
}
static char *CPLGetStaticResult()
{
char *pszStaticResult = (char *) CPLGetTLS( CTLS_PATHBUF );
if( pszStaticResult == NULL )
{
pszStaticResult = (char *) CPLMalloc(CPL_PATH_BUF_SIZE);
CPLSetTLS( CTLS_PATHBUF, pszStaticResult, TRUE );
}
return pszStaticResult;
}
static CPLErrorContext *CPLGetErrorContext()
{
CPLErrorContext *psCtx =
(CPLErrorContext *) CPLGetTLS( CTLS_ERRORCONTEXT );
if( psCtx == NULL )
{
psCtx = (CPLErrorContext *) CPLCalloc(sizeof(CPLErrorContext),1);
psCtx->eLastErrType = CE_None;
psCtx->nLastErrMsgMax = sizeof(psCtx->szLastErrMsg);
CPLSetTLS( CTLS_ERRORCONTEXT, psCtx, TRUE );
}
return psCtx;
}
static CPLErrorContext *CPLGetErrorContext()
{
CPLErrorContext *psCtx =
(CPLErrorContext *) CPLGetTLS( CTLS_ERRORCONTEXT );
if( psCtx == NULL )
{
psCtx = (CPLErrorContext *) VSICalloc(sizeof(CPLErrorContext),1);
if (psCtx == NULL) {
CPLEmergencyError("Out of memory attempting to report error");
}
psCtx->eLastErrType = CE_None;
psCtx->nLastErrMsgMax = sizeof(psCtx->szLastErrMsg);
CPLSetTLS( CTLS_ERRORCONTEXT, psCtx, TRUE );
}
return psCtx;
}
static char *CPLGetStaticResult()
{
char *pachBufRingInfo = (char *) CPLGetTLS( CTLS_PATHBUF );
if( pachBufRingInfo == NULL )
{
pachBufRingInfo = (char *) CPLCalloc(1, sizeof(int) + CPL_PATH_BUF_SIZE * CPL_PATH_BUF_COUNT);
CPLSetTLS( CTLS_PATHBUF, pachBufRingInfo, TRUE );
}
/* -------------------------------------------------------------------- */
/* Work out which string in the "ring" we want to use this */
/* time. */
/* -------------------------------------------------------------------- */
int *pnBufIndex = (int *) pachBufRingInfo;
int nOffset = sizeof(int) + *pnBufIndex * CPL_PATH_BUF_SIZE;
char *pachBuffer = pachBufRingInfo + nOffset;
*pnBufIndex = (*pnBufIndex + 1) % CPL_PATH_BUF_COUNT;
return pachBuffer;
}
void CPLCondWait( void *hCond, void* hClientMutex )
{
Win32Cond* psCond = (Win32Cond*) hCond;
HANDLE hEvent = (HANDLE) CPLGetTLS(CTLS_WIN32_COND);
if (hEvent == NULL)
{
hEvent = CreateEvent(NULL, /* security attributes */
0, /* manual reset = no */
0, /* initial state = unsignaled */
NULL /* no name */);
CPLAssert(hEvent != NULL);
CPLSetTLSWithFreeFunc(CTLS_WIN32_COND, hEvent, CPLTLSFreeEvent);
}
/* Insert the waiter into the waiter list of the condition */
CPLAcquireMutex(psCond->hInternalMutex, 1000.0);
WaiterItem* psItem = (WaiterItem*)malloc(sizeof(WaiterItem));
CPLAssert(psItem != NULL);
psItem->hEvent = hEvent;
psItem->psNext = psCond->psWaiterList;
psCond->psWaiterList = psItem;
CPLReleaseMutex(psCond->hInternalMutex);
/* Release the client mutex before waiting for the event being signaled */
CPLReleaseMutex(hClientMutex);
// Ideally we would check that we do not get WAIT_FAILED but it is hard
// to report a failure.
WaitForSingleObject(hEvent, INFINITE);
/* Reacquire the client mutex */
CPLAcquireMutex(hClientMutex, 1000.0);
}
static CSVTable *CSVAccess( const char * pszFilename )
{
CSVTable *psTable;
FILE *fp;
/* -------------------------------------------------------------------- */
/* Fetch the table, and allocate the thread-local pointer to it */
/* if there isn't already one. */
/* -------------------------------------------------------------------- */
CSVTable **ppsCSVTableList;
ppsCSVTableList = (CSVTable **) CPLGetTLS( CTLS_CSVTABLEPTR );
if( ppsCSVTableList == NULL )
{
ppsCSVTableList = (CSVTable **) CPLCalloc(1,sizeof(CSVTable*));
CPLSetTLSWithFreeFunc( CTLS_CSVTABLEPTR, ppsCSVTableList, CSVFreeTLS );
}
/* -------------------------------------------------------------------- */
/* Is the table already in the list. */
/* -------------------------------------------------------------------- */
for( psTable = *ppsCSVTableList;
psTable != NULL;
psTable = psTable->psNext )
{
if( EQUAL(psTable->pszFilename,pszFilename) )
{
/*
* Eventually we should consider promoting to the front of
* the list to accelerate frequently accessed tables.
*/
return( psTable );
}
}
/* -------------------------------------------------------------------- */
/* If not, try to open it. */
/* -------------------------------------------------------------------- */
fp = VSIFOpen( pszFilename, "rb" );
if( fp == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Create an information structure about this table, and add to */
/* the front of the list. */
/* -------------------------------------------------------------------- */
psTable = (CSVTable *) CPLCalloc(sizeof(CSVTable),1);
psTable->fp = fp;
psTable->pszFilename = CPLStrdup( pszFilename );
psTable->bNonUniqueKey = FALSE; /* as far as we know now */
psTable->psNext = *ppsCSVTableList;
*ppsCSVTableList = psTable;
/* -------------------------------------------------------------------- */
/* Read the table header record containing the field names. */
/* -------------------------------------------------------------------- */
psTable->papszFieldNames = CSVReadParseLine( fp );
return( psTable );
}
const char * GDALDefaultCSVFilename( const char *pszBasename )
{
/* -------------------------------------------------------------------- */
/* Do we already have this file accessed? If so, just return */
/* the existing path without any further probing. */
/* -------------------------------------------------------------------- */
CSVTable **ppsCSVTableList;
ppsCSVTableList = (CSVTable **) CPLGetTLS( CTLS_CSVTABLEPTR );
if( ppsCSVTableList != NULL )
{
CSVTable *psTable;
int nBasenameLen = strlen(pszBasename);
for( psTable = *ppsCSVTableList;
psTable != NULL;
psTable = psTable->psNext )
{
int nFullLen = strlen(psTable->pszFilename);
if( nFullLen > nBasenameLen
&& strcmp(psTable->pszFilename+nFullLen-nBasenameLen,
pszBasename) == 0
&& strchr("/\\",psTable->pszFilename[+nFullLen-nBasenameLen-1])
!= NULL )
{
return psTable->pszFilename;
}
}
}
/* -------------------------------------------------------------------- */
/* Otherwise we need to look harder for it. */
/* -------------------------------------------------------------------- */
DefaultCSVFileNameTLS* pTLSData =
(DefaultCSVFileNameTLS *) CPLGetTLS( CTLS_CSVDEFAULTFILENAME );
if (pTLSData == NULL)
{
pTLSData = (DefaultCSVFileNameTLS*) CPLCalloc(1, sizeof(DefaultCSVFileNameTLS));
CPLSetTLS( CTLS_CSVDEFAULTFILENAME, pTLSData, TRUE );
}
FILE *fp = NULL;
const char *pszResult;
pszResult = CPLFindFile( "epsg_csv", pszBasename );
if( pszResult != NULL )
return pszResult;
if( !pTLSData->bCSVFinderInitialized )
{
pTLSData->bCSVFinderInitialized = TRUE;
if( CPLGetConfigOption("GEOTIFF_CSV",NULL) != NULL )
CPLPushFinderLocation( CPLGetConfigOption("GEOTIFF_CSV",NULL));
if( CPLGetConfigOption("GDAL_DATA",NULL) != NULL )
CPLPushFinderLocation( CPLGetConfigOption("GDAL_DATA",NULL) );
pszResult = CPLFindFile( "epsg_csv", pszBasename );
if( pszResult != NULL )
return pszResult;
}
if( (fp = fopen( "csv/horiz_cs.csv", "rt" )) != NULL )
{
strcpy( pTLSData->szPath, "csv/" );
CPLStrlcat( pTLSData->szPath, pszBasename, sizeof(pTLSData->szPath) );
}
else
{
#ifdef GDAL_PREFIX
#ifdef MACOSX_FRAMEWORK
strcpy( pTLSData->szPath, GDAL_PREFIX "/Resources/epsg_csv/" );
CPLStrlcat( pTLSData->szPath, pszBasename, sizeof(pTLSData->szPath) );
#else
strcpy( pTLSData->szPath, GDAL_PREFIX "/share/epsg_csv/" );
CPLStrlcat( pTLSData->szPath, pszBasename, sizeof(pTLSData->szPath) );
#endif
#else
strcpy( pTLSData->szPath, "/usr/local/share/epsg_csv/" );
CPLStrlcat( pTLSData->szPath, pszBasename, sizeof(pTLSData->szPath) );
#endif
if( (fp = fopen( pTLSData->szPath, "rt" )) == NULL )
CPLStrlcpy( pTLSData->szPath, pszBasename, sizeof(pTLSData->szPath) );
}
if( fp != NULL )
fclose( fp );
return( pTLSData->szPath );
}
