DBFOpenLL()

DBFHandle SHPAPI_CALL DBFOpenLL	(	const char *	pszDBFFile,
		const char *	pszAccess,
		SAHooks *	psHooks
	)

Definition at line 382 of file dbfopen.c.

{
    DBFHandle           psDBF;
    SAFile              pfCPG;
    unsigned char       *pabyBuf;
    int                 nFields, nHeadLen, iField, i;
    char                *pszBasename, *pszFullname;
    int                 nBufSize = 500;
 
/* -------------------------------------------------------------------- */
/*      We only allow the access strings "rb" and "r+".                  */
/* -------------------------------------------------------------------- */
    if( strcmp(pszAccess,"r") != 0 && strcmp(pszAccess,"r+") != 0
        && strcmp(pszAccess,"rb") != 0 && strcmp(pszAccess,"rb+") != 0
        && strcmp(pszAccess,"r+b") != 0 )
        return( NULL );
 
    if( strcmp(pszAccess,"r") == 0 )
        pszAccess = "rb";
 
    if( strcmp(pszAccess,"r+") == 0 )
        pszAccess = "rb+";
 
/* -------------------------------------------------------------------- */
/*      Compute the base (layer) name.  If there is any extension       */
/*      on the passed in filename we will strip it off.                 */
/* -------------------------------------------------------------------- */
    pszBasename = (char *) malloc(strlen(pszFilename)+5);
    strcpy( pszBasename, pszFilename );
    for( i = strlen(pszBasename)-1;
         i > 0 && pszBasename[i] != '.' && pszBasename[i] != '/'
               && pszBasename[i] != '\\';
         i-- ) {}
 
    if( pszBasename[i] == '.' )
        pszBasename[i] = '\0';
 
    pszFullname = (char *) malloc(strlen(pszBasename) + 5);
    sprintf( pszFullname, "%s.dbf", pszBasename );
 
    psDBF = (DBFHandle) calloc( 1, sizeof(DBFInfo) );
    psDBF->fp = psHooks->FOpen( pszFullname, pszAccess );
    memcpy( &(psDBF->sHooks), psHooks, sizeof(SAHooks) );
 
    if( psDBF->fp == NULL )
    {
        sprintf( pszFullname, "%s.DBF", pszBasename );
        psDBF->fp = psDBF->sHooks.FOpen(pszFullname, pszAccess );
    }
 
    sprintf( pszFullname, "%s.cpg", pszBasename );
    pfCPG = psHooks->FOpen( pszFullname, "r" );
    if( pfCPG == NULL )
    {
        sprintf( pszFullname, "%s.CPG", pszBasename );
        pfCPG = psHooks->FOpen( pszFullname, "r" );
    }
 
    free( pszBasename );
    free( pszFullname );
 
    if( psDBF->fp == NULL )
    {
        free( psDBF );
        if( pfCPG ) psHooks->FClose( pfCPG );
        return( NULL );
    }
 
    psDBF->bNoHeader = FALSE;
    psDBF->nCurrentRecord = -1;
    psDBF->bCurrentRecordModified = FALSE;
 
/* -------------------------------------------------------------------- */
/*  Read Table Header info                                              */
/* -------------------------------------------------------------------- */
    pabyBuf = (unsigned char *) malloc(nBufSize);
    if( psDBF->sHooks.FRead( pabyBuf, 32, 1, psDBF->fp ) != 1 )
    {
        psDBF->sHooks.FClose( psDBF->fp );
        if( pfCPG ) psDBF->sHooks.FClose( pfCPG );
        free( pabyBuf );
        free( psDBF );
        return NULL;
    }
 
    psDBF->nRecords =
     pabyBuf[4] + pabyBuf[5]*256 + pabyBuf[6]*256*256 + pabyBuf[7]*256*256*256;
 
    psDBF->nHeaderLength = nHeadLen = pabyBuf[8] + pabyBuf[9]*256;
    psDBF->nRecordLength = pabyBuf[10] + pabyBuf[11]*256;
    psDBF->iLanguageDriver = pabyBuf[29];
 
    if (nHeadLen < 32)
    {
        psDBF->sHooks.FClose( psDBF->fp );
        if( pfCPG ) psDBF->sHooks.FClose( pfCPG );
        free( pabyBuf );
        free( psDBF );
        return NULL;
    }
 
    psDBF->nFields = nFields = (nHeadLen - 32) / 32;
 
    psDBF->pszCurrentRecord = (char *) malloc(psDBF->nRecordLength);
 
/* -------------------------------------------------------------------- */
/*  Figure out the code page from the LDID and CPG                      */
/* -------------------------------------------------------------------- */
 
    psDBF->pszCodePage = NULL;
    if( pfCPG )
    {
        size_t n;
        memset( pabyBuf, 0, nBufSize);
        psDBF->sHooks.FRead( pabyBuf, nBufSize - 1, 1, pfCPG );
        n = strcspn( (char *) pabyBuf, "\n\r" );
        if( n > 0 )
        {
            pabyBuf[n] = '\0';
            psDBF->pszCodePage = (char *) malloc(n + 1);
            memcpy( psDBF->pszCodePage, pabyBuf, n + 1 );
        }
                psDBF->sHooks.FClose( pfCPG );
    }
    if( (psDBF->pszCodePage == NULL) && (psDBF->iLanguageDriver != 0) )
    {
        sprintf( (char *) pabyBuf, "LDID/%d", psDBF->iLanguageDriver );
        psDBF->pszCodePage = (char *) malloc(strlen((char*)pabyBuf) + 1);
        strcpy( psDBF->pszCodePage, (char *) pabyBuf );
    }
 
/* -------------------------------------------------------------------- */
/*  Read in Field Definitions                                           */
/* -------------------------------------------------------------------- */
 
    pabyBuf = (unsigned char *) SfRealloc(pabyBuf,nHeadLen);
    psDBF->pszHeader = (char *) pabyBuf;
 
    psDBF->sHooks.FSeek( psDBF->fp, 32, 0 );
    if( psDBF->sHooks.FRead( pabyBuf, nHeadLen-32, 1, psDBF->fp ) != 1 )
    {
        psDBF->sHooks.FClose( psDBF->fp );
        free( pabyBuf );
        free( psDBF->pszCurrentRecord );
        free( psDBF );
        return NULL;
    }
 
    psDBF->panFieldOffset = (int *) malloc(sizeof(int) * nFields);
    psDBF->panFieldSize = (int *) malloc(sizeof(int) * nFields);
    psDBF->panFieldDecimals = (int *) malloc(sizeof(int) * nFields);
    psDBF->pachFieldType = (char *) malloc(sizeof(char) * nFields);
 
    for( iField = 0; iField < nFields; iField++ )
    {
        unsigned char           *pabyFInfo;
 
        pabyFInfo = pabyBuf+iField*32;
 
        if( pabyFInfo[11] == 'N' || pabyFInfo[11] == 'F' )
        {
            psDBF->panFieldSize[iField] = pabyFInfo[16];
            psDBF->panFieldDecimals[iField] = pabyFInfo[17];
        }
        else
        {
            psDBF->panFieldSize[iField] = pabyFInfo[16];
            psDBF->panFieldDecimals[iField] = 0;
 
/*
** The following seemed to be used sometimes to handle files with long
** string fields, but in other cases (such as bug 1202) the decimals field
** just seems to indicate some sort of preferred formatting, not very
** wide fields.  So I have disabled this code.  FrankW.
            psDBF->panFieldSize[iField] = pabyFInfo[16] + pabyFInfo[17]*256;
            psDBF->panFieldDecimals[iField] = 0;
*/
        }
 
        psDBF->pachFieldType[iField] = (char) pabyFInfo[11];
        if( iField == 0 )
            psDBF->panFieldOffset[iField] = 1;
        else
            psDBF->panFieldOffset[iField] =
              psDBF->panFieldOffset[iField-1] + psDBF->panFieldSize[iField-1];
    }
 
    return( psDBF );
}

References FALSE, SAHooks::FClose, SAHooks::FOpen, free(), malloc(), and SfRealloc().

Referenced by DBFOpen().

Here is the call graph for this function:

Here is the caller graph for this function: