DBFAlterFieldDefn()

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

Definition at line 2035 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';
 
    if( (int) strlen(pszFieldName) < 10 )
        strncpy( pszFInfo, pszFieldName, strlen(pszFieldName));
    else
        strncpy( pszFInfo, pszFieldName, 10);
 
    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: