DBFAlterFieldDefn()

int SHPAPI_CALL DBFAlterFieldDefn	(	DBFHandle	psDBF,
		int	iField,
		const char *	pszFieldName,
		char	chType,
		int	nWidth,
		int	nDecimals
	)

Definition at line 1965 of file dbfopen.c.

{
        int i;
        int iRecord;
        int nOffset;
        int nOldWidth;
        int nOldRecordLength;
        int nRecordOffset;
        char *pszFInfo;
        char chOldType;
        int bIsNULL;
        char chFieldFill;
 
        if (iField < 0 || iField >= psDBF->nFields)
                return FALSE;
 
        /* make sure that everything is written in .dbf */
        if (!DBFFlushRecord(psDBF))
                return FALSE;
 
        chFieldFill = DBFGetNullCharacter(chType);
 
        chOldType = psDBF->pachFieldType[iField];
        nOffset = psDBF->panFieldOffset[iField];
        nOldWidth = psDBF->panFieldSize[iField];
        nOldRecordLength = psDBF->nRecordLength;
 
        /* -------------------------------------------------------------------- */
        /*      Do some checking to ensure we can add records to this file.     */
        /* -------------------------------------------------------------------- */
        if (nWidth < 1)
                return -1;
 
        if (nWidth > 255)
                nWidth = 255;
 
        /* -------------------------------------------------------------------- */
        /*      Assign the new field information fields.                        */
        /* -------------------------------------------------------------------- */
        psDBF->panFieldSize[iField] = nWidth;
        psDBF->panFieldDecimals[iField] = nDecimals;
        psDBF->pachFieldType[iField] = chType;
 
        /* -------------------------------------------------------------------- */
        /*      Update the header information.                                  */
        /* -------------------------------------------------------------------- */
        pszFInfo = psDBF->pszHeader + 32 * iField;
 
        for (i = 0; i < 32; i++)
                pszFInfo[i] = '\0';
 
        snprintf(pszFInfo, 10, "%s", pszFieldName);
 
        pszFInfo[11] = psDBF->pachFieldType[iField];
 
        if (chType == 'C')
        {
                pszFInfo[16] = (unsigned char)(nWidth % 256);
                pszFInfo[17] = (unsigned char)(nWidth / 256);
        }
        else
        {
                pszFInfo[16] = (unsigned char)nWidth;
                pszFInfo[17] = (unsigned char)nDecimals;
        }
 
        /* -------------------------------------------------------------------- */
        /*      Update offsets                                                  */
        /* -------------------------------------------------------------------- */
        if (nWidth != nOldWidth)
        {
                for (i = iField + 1; i < psDBF->nFields; i++)
                        psDBF->panFieldOffset[i] += nWidth - nOldWidth;
                psDBF->nRecordLength += nWidth - nOldWidth;
 
                psDBF->pszCurrentRecord = (char *)SfRealloc(psDBF->pszCurrentRecord, psDBF->nRecordLength);
        }
 
        /* we're done if we're dealing with not yet created .dbf */
        if (psDBF->bNoHeader && psDBF->nRecords == 0)
                return TRUE;
 
        /* force update of header with new header and record length */
        psDBF->bNoHeader = TRUE;
        DBFUpdateHeader(psDBF);
 
        if (nWidth < nOldWidth || (nWidth == nOldWidth && chType != chOldType))
        {
                char *pszRecord = (char *)malloc(sizeof(char) * nOldRecordLength);
                char *pszOldField = (char *)malloc(sizeof(char) * (nOldWidth + 1));
 
                pszOldField[nOldWidth] = 0;
 
                /* move records to their new positions */
                for (iRecord = 0; iRecord < psDBF->nRecords; iRecord++)
                {
                        nRecordOffset = nOldRecordLength * (SAOffset)iRecord + psDBF->nHeaderLength;
 
                        /* load record */
                        psDBF->sHooks.FSeek(psDBF->fp, nRecordOffset, 0);
                        psDBF->sHooks.FRead(pszRecord, nOldRecordLength, 1, psDBF->fp);
 
                        memcpy(pszOldField, pszRecord + nOffset, nOldWidth);
                        bIsNULL = DBFIsValueNULL(chOldType, pszOldField);
 
                        if (nWidth != nOldWidth)
                        {
                                if ((chOldType == 'N' || chOldType == 'F') && pszOldField[0] == ' ')
                                {
                                        /* Strip leading spaces when truncating a numeric field */
                                        memmove(pszRecord + nOffset, pszRecord + nOffset + nOldWidth - nWidth, nWidth);
                                }
                                if (nOffset + nOldWidth < nOldRecordLength)
                                {
                                        memmove(pszRecord + nOffset + nWidth,
                                                pszRecord + nOffset + nOldWidth,
                                                nOldRecordLength - (nOffset + nOldWidth));
                                }
                        }
 
                        /* Convert null value to the appropriate value of the new type */
                        if (bIsNULL)
                        {
                                memset(pszRecord + nOffset, chFieldFill, nWidth);
                        }
 
                        nRecordOffset = psDBF->nRecordLength * (SAOffset)iRecord + psDBF->nHeaderLength;
 
                        /* write record */
                        psDBF->sHooks.FSeek(psDBF->fp, nRecordOffset, 0);
                        psDBF->sHooks.FWrite(pszRecord, psDBF->nRecordLength, 1, psDBF->fp);
                }
 
                free(pszRecord);
                free(pszOldField);
        }
        else if (nWidth > nOldWidth)
        {
                char *pszRecord = (char *)malloc(sizeof(char) * psDBF->nRecordLength);
                char *pszOldField = (char *)malloc(sizeof(char) * (nOldWidth + 1));
 
                pszOldField[nOldWidth] = 0;
 
                /* move records to their new positions */
                for (iRecord = psDBF->nRecords - 1; iRecord >= 0; iRecord--)
                {
                        nRecordOffset = nOldRecordLength * (SAOffset)iRecord + psDBF->nHeaderLength;
 
                        /* load record */
                        psDBF->sHooks.FSeek(psDBF->fp, nRecordOffset, 0);
                        psDBF->sHooks.FRead(pszRecord, nOldRecordLength, 1, psDBF->fp);
 
                        memcpy(pszOldField, pszRecord + nOffset, nOldWidth);
                        bIsNULL = DBFIsValueNULL(chOldType, pszOldField);
 
                        if (nOffset + nOldWidth < nOldRecordLength)
                        {
                                memmove(pszRecord + nOffset + nWidth,
                                        pszRecord + nOffset + nOldWidth,
                                        nOldRecordLength - (nOffset + nOldWidth));
                        }
 
                        /* Convert null value to the appropriate value of the new type */
                        if (bIsNULL)
                        {
                                memset(pszRecord + nOffset, chFieldFill, nWidth);
                        }
                        else
                        {
                                if ((chOldType == 'N' || chOldType == 'F'))
                                {
                                        /* Add leading spaces when expanding a numeric field */
                                        memmove(
                                            pszRecord + nOffset + nWidth - nOldWidth, pszRecord + nOffset, nOldWidth);
                                        memset(pszRecord + nOffset, ' ', nWidth - nOldWidth);
                                }
                                else
                                {
                                        /* Add trailing spaces */
                                        memset(pszRecord + nOffset + nOldWidth, ' ', nWidth - nOldWidth);
                                }
                        }
 
                        nRecordOffset = psDBF->nRecordLength * (SAOffset)iRecord + psDBF->nHeaderLength;
 
                        /* write record */
                        psDBF->sHooks.FSeek(psDBF->fp, nRecordOffset, 0);
                        psDBF->sHooks.FWrite(pszRecord, psDBF->nRecordLength, 1, psDBF->fp);
                }
 
                free(pszRecord);
                free(pszOldField);
        }
 
        psDBF->nCurrentRecord = -1;
        psDBF->bCurrentRecordModified = FALSE;
 
        return TRUE;
}

References DBFFlushRecord(), DBFGetNullCharacter(), DBFIsValueNULL(), DBFUpdateHeader(), FALSE, free(), malloc(), SfRealloc(), and TRUE.

Here is the call graph for this function: