DBFOpenLL()

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

Definition at line 370 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: