int SHPAPI_CALL
DBFWriteTuple(DBFHandle psDBF, int hEntity, void * pRawTuple )
{
int nRecordOffset, i;
unsigned char *pabyRec;
/* -------------------------------------------------------------------- */
/* Is this a valid record? */
/* -------------------------------------------------------------------- */
if( hEntity < 0 || hEntity > psDBF->nRecords )
return( FALSE );
if( psDBF->bNoHeader )
DBFWriteHeader(psDBF);
/* -------------------------------------------------------------------- */
/* Is this a brand new record? */
/* -------------------------------------------------------------------- */
if( hEntity == psDBF->nRecords )
{
DBFFlushRecord( psDBF );
psDBF->nRecords++;
for( i = 0; i < psDBF->nRecordLength; i++ )
psDBF->pszCurrentRecord[i] = ' ';
psDBF->nCurrentRecord = hEntity;
}
/* -------------------------------------------------------------------- */
/* Is this an existing record, but different than the last one */
/* we accessed? */
/* -------------------------------------------------------------------- */
if( psDBF->nCurrentRecord != hEntity )
{
DBFFlushRecord( psDBF );
nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;
fseek( psDBF->fp, nRecordOffset, 0 );
if (fread( psDBF->pszCurrentRecord, psDBF->nRecordLength,
1, psDBF->fp ) != 1) error("binary read error");
psDBF->nCurrentRecord = hEntity;
}
pabyRec = (unsigned char *) psDBF->pszCurrentRecord;
memcpy ( pabyRec, pRawTuple, psDBF->nRecordLength );
psDBF->bCurrentRecordModified = TRUE;
psDBF->bUpdated = TRUE;
return( TRUE );
}
void SHPAPI_CALL
DBFUpdateHeader( DBFHandle psDBF )
{
unsigned char abyFileHeader[32];
if( psDBF->bNoHeader )
DBFWriteHeader( psDBF );
DBFFlushRecord( psDBF );
fseek( psDBF->fp, 0, 0 );
if(fread( abyFileHeader, 32, 1, psDBF->fp ) != 1)
error("binary read error");
abyFileHeader[4] = psDBF->nRecords % 256;
abyFileHeader[5] = (psDBF->nRecords/256) % 256;
abyFileHeader[6] = (psDBF->nRecords/(256*256)) % 256;
abyFileHeader[7] = (psDBF->nRecords/(256*256*256)) % 256;
fseek( psDBF->fp, 0, 0 );
if (fwrite( abyFileHeader, 32, 1, psDBF->fp ) != 1)
error("binary write error");
fflush( psDBF->fp );
}
void SHPAPI_CALL
DBFClose(DBFHandle psDBF)
{
/* -------------------------------------------------------------------- */
/* Write out header if not already written. */
/* -------------------------------------------------------------------- */
if( psDBF->bNoHeader )
DBFWriteHeader( psDBF );
DBFFlushRecord( psDBF );
/* -------------------------------------------------------------------- */
/* Update last access date, and number of records if we have */
/* write access. */
/* -------------------------------------------------------------------- */
if( psDBF->bUpdated )
{
unsigned char abyFileHeader[32];
fseek( psDBF->fp, 0, 0 );
fread( abyFileHeader, 32, 1, psDBF->fp );
abyFileHeader[1] = 95; /* YY */
abyFileHeader[2] = 7; /* MM */
abyFileHeader[3] = 26; /* DD */
abyFileHeader[4] = psDBF->nRecords % 256;
abyFileHeader[5] = (psDBF->nRecords/256) % 256;
abyFileHeader[6] = (psDBF->nRecords/(256*256)) % 256;
abyFileHeader[7] = (psDBF->nRecords/(256*256*256)) % 256;
fseek( psDBF->fp, 0, 0 );
fwrite( abyFileHeader, 32, 1, psDBF->fp );
}
/* -------------------------------------------------------------------- */
/* Close, and free resources. */
/* -------------------------------------------------------------------- */
fclose( psDBF->fp );
if( psDBF->panFieldOffset != NULL )
{
free( psDBF->panFieldOffset );
free( psDBF->panFieldSize );
free( psDBF->panFieldDecimals );
free( psDBF->pachFieldType );
}
free( psDBF->pszHeader );
free( psDBF->pszCurrentRecord );
free( psDBF );
if( pszStringField != NULL )
{
free( pszStringField );
pszStringField = NULL;
nStringFieldLen = 0;
}
}
void SHPAPI_CALL
DBFClose(DBFHandle psDBF)
{
/* -------------------------------------------------------------------- */
/* Write out header if not already written. */
/* -------------------------------------------------------------------- */
if( psDBF->bNoHeader )
DBFWriteHeader( psDBF );
DBFFlushRecord( psDBF );
/* -------------------------------------------------------------------- */
/* Update last access date, and number of records if we have */
/* write access. */
/* -------------------------------------------------------------------- */
if( psDBF->bUpdated )
DBFUpdateHeader( psDBF );
/* -------------------------------------------------------------------- */
/* Close, and free resources. */
/* -------------------------------------------------------------------- */
fclose( psDBF->fp );
if( psDBF->panFieldOffset != NULL )
{
free( psDBF->panFieldOffset );
free( psDBF->panFieldSize );
free( psDBF->panFieldDecimals );
free( psDBF->pachFieldType );
}
free( psDBF->pszHeader );
free( psDBF->pszCurrentRecord );
free( psDBF );
if( pszStringField != NULL )
{
free( pszStringField );
pszStringField = NULL;
nStringFieldLen = 0;
}
}
DBFReadTuple(DBFHandle psDBF, int hEntity )
{
int nRecordOffset;
unsigned char *pabyRec;
static char *pReturnTuple = NULL;
static int nTupleLen = 0;
/* -------------------------------------------------------------------- */
/* Have we read the record? */
/* -------------------------------------------------------------------- */
if( hEntity < 0 || hEntity >= psDBF->nRecords )
return( NULL );
if( psDBF->nCurrentRecord != hEntity )
{
DBFFlushRecord( psDBF );
nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;
fseek( psDBF->fp, nRecordOffset, 0 );
if (fread( psDBF->pszCurrentRecord, psDBF->nRecordLength,
1, psDBF->fp ) != 1) error("binary read error");
psDBF->nCurrentRecord = hEntity;
}
pabyRec = (unsigned char *) psDBF->pszCurrentRecord;
if ( nTupleLen < psDBF->nRecordLength) {
nTupleLen = psDBF->nRecordLength;
pReturnTuple = (char *) SfRealloc(pReturnTuple, psDBF->nRecordLength);
}
memcpy ( pReturnTuple, pabyRec, psDBF->nRecordLength );
return( pReturnTuple );
}
static int DBFWriteAttribute(DBFHandle psDBF, int hEntity, int iField,
void * pValue )
{
int nRecordOffset, i, j;
uchar *pabyRec;
char szSField[40], szFormat[12];
/* -------------------------------------------------------------------- */
/* Is this a valid record? */
/* -------------------------------------------------------------------- */
if( hEntity < 0 || hEntity > psDBF->nRecords )
return( FALSE );
if( psDBF->bNoHeader )
DBFWriteHeader(psDBF);
/* -------------------------------------------------------------------- */
/* Is this a brand new record? */
/* -------------------------------------------------------------------- */
if( hEntity == psDBF->nRecords )
{
DBFFlushRecord( psDBF );
psDBF->nRecords++;
for( i = 0; i < psDBF->nRecordLength; i++ )
psDBF->pszCurrentRecord[i] = ' ';
psDBF->nCurrentRecord = hEntity;
}
/* -------------------------------------------------------------------- */
/* Is this an existing record, but different than the last one */
/* we accessed? */
/* -------------------------------------------------------------------- */
if( psDBF->nCurrentRecord != hEntity )
{
DBFFlushRecord( psDBF );
nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;
fseek( psDBF->fp, nRecordOffset, 0 );
fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );
psDBF->nCurrentRecord = hEntity;
}
pabyRec = (uchar *) psDBF->pszCurrentRecord;
/* -------------------------------------------------------------------- */
/* Assign all the record fields. */
/* -------------------------------------------------------------------- */
switch( psDBF->pachFieldType[iField] )
{
case 'D':
case 'N':
case 'F':
if( psDBF->panFieldDecimals[iField] == 0 )
{
sprintf( szFormat, "%%%dd", psDBF->panFieldSize[iField] );
sprintf(szSField, szFormat, (int) *((double *) pValue) );
if( strlen(szSField) > psDBF->panFieldSize[iField] )
szSField[psDBF->panFieldSize[iField]] = '\0';
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
szSField, strlen(szSField) );
}
else
{
sprintf( szFormat, "%%%d.%df",
psDBF->panFieldSize[iField],
psDBF->panFieldDecimals[iField] );
sprintf(szSField, szFormat, *((double *) pValue) );
if( strlen(szSField) > psDBF->panFieldSize[iField] )
szSField[psDBF->panFieldSize[iField]] = '\0';
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
szSField, strlen(szSField) );
}
break;
default:
if( strlen((char *) pValue) > psDBF->panFieldSize[iField] )
j = psDBF->panFieldSize[iField];
else
{
memset( pabyRec+psDBF->panFieldOffset[iField], ' ',
psDBF->panFieldSize[iField] );
j = strlen((char *) pValue);
}
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
(char *) pValue, j );
break;
}
psDBF->bCurrentRecordModified = TRUE;
psDBF->bUpdated = TRUE;
return( TRUE );
}
static void *DBFReadAttribute(DBFHandle psDBF, int hEntity, int iField,
char chReqType )
{
int nRecordOffset;
uchar *pabyRec;
void *pReturnField = NULL;
static double dDoubleField;
/* -------------------------------------------------------------------- */
/* Have we read the record? */
/* -------------------------------------------------------------------- */
if( hEntity < 0 || hEntity >= psDBF->nRecords )
return( NULL );
if( psDBF->nCurrentRecord != hEntity )
{
DBFFlushRecord( psDBF );
nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;
fseek( psDBF->fp, nRecordOffset, 0 );
fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );
psDBF->nCurrentRecord = hEntity;
}
pabyRec = (uchar *) psDBF->pszCurrentRecord;
/* -------------------------------------------------------------------- */
/* Ensure our field buffer is large enough to hold this buffer. */
/* -------------------------------------------------------------------- */
if( psDBF->panFieldSize[iField]+1 > nStringFieldLen )
{
nStringFieldLen = psDBF->panFieldSize[iField]*2 + 10;
pszStringField = (char *) SfRealloc(pszStringField,nStringFieldLen);
}
/* -------------------------------------------------------------------- */
/* Extract the requested field. */
/* -------------------------------------------------------------------- */
strncpy( pszStringField, (const char *)pabyRec+psDBF->panFieldOffset[iField],
psDBF->panFieldSize[iField] );
pszStringField[psDBF->panFieldSize[iField]] = '\0';
pReturnField = pszStringField;
/* -------------------------------------------------------------------- */
/* Decode the field. */
/* -------------------------------------------------------------------- */
if( chReqType == 'N' )
{
sscanf( pszStringField, "%lf", &dDoubleField );
pReturnField = &dDoubleField;
}
/* -------------------------------------------------------------------- */
/* Should we trim white space off the string attribute value? */
/* -------------------------------------------------------------------- */
#ifdef TRIM_DBF_WHITESPACE
else
{
char *pchSrc, *pchDst;
pchDst = pchSrc = pszStringField;
while( *pchSrc == ' ' )
pchSrc++;
while( *pchSrc != '\0' )
*(pchDst++) = *(pchSrc++);
*pchDst = '\0';
while( *(--pchDst) == ' ' && pchDst != pszStringField )
*pchDst = '\0';
}
#endif
return( pReturnField );
}
static int DBFWriteAttribute(DBFHandle psDBF, int hEntity, int iField,
void * pValue )
{
int nRecordOffset, i, j, nRetResult = TRUE;
unsigned char *pabyRec;
char szSField[400], szFormat[20];
/* -------------------------------------------------------------------- */
/* Is this a valid record? */
/* -------------------------------------------------------------------- */
if( hEntity < 0 || hEntity > psDBF->nRecords )
return( FALSE );
if( psDBF->bNoHeader )
DBFWriteHeader(psDBF);
/* -------------------------------------------------------------------- */
/* Is this a brand new record? */
/* -------------------------------------------------------------------- */
if( hEntity == psDBF->nRecords )
{
DBFFlushRecord( psDBF );
psDBF->nRecords++;
for( i = 0; i < psDBF->nRecordLength; i++ )
psDBF->pszCurrentRecord[i] = ' ';
psDBF->nCurrentRecord = hEntity;
}
/* -------------------------------------------------------------------- */
/* Is this an existing record, but different than the last one */
/* we accessed? */
/* -------------------------------------------------------------------- */
if( psDBF->nCurrentRecord != hEntity )
{
DBFFlushRecord( psDBF );
nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;
fseek( psDBF->fp, nRecordOffset, 0 );
if (fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1,
psDBF->fp ) != 1) error("binary read error");
psDBF->nCurrentRecord = hEntity;
}
pabyRec = (unsigned char *) psDBF->pszCurrentRecord;
psDBF->bCurrentRecordModified = TRUE;
psDBF->bUpdated = TRUE;
/* -------------------------------------------------------------------- */
/* Translate NULL value to valid DBF file representation. */
/* */
/* Contributed by Jim Matthews. */
/* -------------------------------------------------------------------- */
if( pValue == NULL )
{
switch(psDBF->pachFieldType[iField])
{
case 'N':
case 'F':
/* NULL numeric fields have value "****************" */
memset( (char *) (pabyRec+psDBF->panFieldOffset[iField]), '*',
psDBF->panFieldSize[iField] );
break;
case 'D':
/* NULL date fields have value "00000000" */
memset( (char *) (pabyRec+psDBF->panFieldOffset[iField]), '0',
psDBF->panFieldSize[iField] );
break;
case 'L':
/* NULL boolean fields have value "?" */
memset( (char *) (pabyRec+psDBF->panFieldOffset[iField]), '?',
psDBF->panFieldSize[iField] );
break;
default:
/* empty string fields are considered NULL */
memset( (char *) (pabyRec+psDBF->panFieldOffset[iField]), '\0',
psDBF->panFieldSize[iField] );
break;
}
return TRUE;
}
/* -------------------------------------------------------------------- */
/* Assign all the record fields. */
/* -------------------------------------------------------------------- */
switch( psDBF->pachFieldType[iField] )
{
/* case 'D': is Date */
case 'N':
case 'F':
if( psDBF->panFieldDecimals[iField] == 0 )
{
int nWidth = psDBF->panFieldSize[iField];
if( sizeof(szSField)-2 < nWidth )
nWidth = sizeof(szSField)-2;
sprintf( szFormat, "%%%dd", nWidth );
sprintf(szSField, szFormat, (int) *((double *) pValue) );
if( (int)strlen(szSField) > psDBF->panFieldSize[iField] )
{
szSField[psDBF->panFieldSize[iField]] = '\0';
nRetResult = FALSE;
}
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
szSField, strlen(szSField) );
}
else
{
int nWidth = psDBF->panFieldSize[iField];
if( sizeof(szSField)-2 < nWidth )
nWidth = sizeof(szSField)-2;
sprintf( szFormat, "%%%d.%df",
nWidth, psDBF->panFieldDecimals[iField] );
sprintf(szSField, szFormat, *((double *) pValue) );
if( (int) strlen(szSField) > psDBF->panFieldSize[iField] )
{
szSField[psDBF->panFieldSize[iField]] = '\0';
nRetResult = FALSE;
}
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
szSField, strlen(szSField) );
}
break;
case 'L':
if (psDBF->panFieldSize[iField] >= 1 &&
(*(char*)pValue == 'F' || *(char*)pValue == 'T'))
*(pabyRec+psDBF->panFieldOffset[iField]) = *(char*)pValue;
break;
default:
if( (int) strlen((char *) pValue) > psDBF->panFieldSize[iField] )
{
j = psDBF->panFieldSize[iField];
nRetResult = FALSE;
}
else
{
memset( pabyRec+psDBF->panFieldOffset[iField], ' ',
psDBF->panFieldSize[iField] );
j = strlen((char *) pValue);
}
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
(char *) pValue, j );
break;
}
return( nRetResult );
}
int DBFWriteAttributeDirectly(DBFHandle psDBF, int hEntity, int iField,
void * pValue )
{
int nRecordOffset, i, j;
unsigned char *pabyRec;
/* -------------------------------------------------------------------- */
/* Is this a valid record? */
/* -------------------------------------------------------------------- */
if( hEntity < 0 || hEntity > psDBF->nRecords )
return( FALSE );
if( psDBF->bNoHeader )
DBFWriteHeader(psDBF);
/* -------------------------------------------------------------------- */
/* Is this a brand new record? */
/* -------------------------------------------------------------------- */
if( hEntity == psDBF->nRecords )
{
DBFFlushRecord( psDBF );
psDBF->nRecords++;
for( i = 0; i < psDBF->nRecordLength; i++ )
psDBF->pszCurrentRecord[i] = ' ';
psDBF->nCurrentRecord = hEntity;
}
/* -------------------------------------------------------------------- */
/* Is this an existing record, but different than the last one */
/* we accessed? */
/* -------------------------------------------------------------------- */
if( psDBF->nCurrentRecord != hEntity )
{
DBFFlushRecord( psDBF );
nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;
fseek( psDBF->fp, nRecordOffset, 0 );
if (fread( psDBF->pszCurrentRecord, psDBF->nRecordLength,
1, psDBF->fp ) != 1) error("binary read error");
psDBF->nCurrentRecord = hEntity;
}
pabyRec = (unsigned char *) psDBF->pszCurrentRecord;
/* -------------------------------------------------------------------- */
/* Assign all the record fields. */
/* -------------------------------------------------------------------- */
if( (int)strlen((char *) pValue) > psDBF->panFieldSize[iField] )
j = psDBF->panFieldSize[iField];
else
{
memset( pabyRec+psDBF->panFieldOffset[iField], ' ',
psDBF->panFieldSize[iField] );
j = strlen((char *) pValue);
}
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
(char *) pValue, j );
psDBF->bCurrentRecordModified = TRUE;
psDBF->bUpdated = TRUE;
return( TRUE );
}
int CDbfFile::WriteRecord(int hEntity, int iField, void *pValue)
{
int nRecordOffset, i, j;
uchar *pabyRec;
char szSField[40], szFormat[12];
/* -------------------------------------------------------------------- */
/* Is this a valid record? */
/* -------------------------------------------------------------------- */
if( hEntity < 0 || hEntity > hDBF->nRecords )
return( FALSE );
if( hDBF->bNoHeader )
DBFWriteHeader(hDBF);
/* -------------------------------------------------------------------- */
/* Is this a brand new record? */
/* -------------------------------------------------------------------- */
if( hEntity == hDBF->nRecords )
{
DBFFlushRecord( hDBF );
hDBF->nRecords++;
for( i = 0; i < hDBF->nRecordLength; i++ )
hDBF->pszCurrentRecord[i] = ' ';
hDBF->nCurrentRecord = hEntity;
}
/* -------------------------------------------------------------------- */
/* Is this an existing record, but different than the last one */
/* we accessed? */
/* -------------------------------------------------------------------- */
if( hDBF->nCurrentRecord != hEntity )
{
DBFFlushRecord( hDBF );
nRecordOffset = hDBF->nRecordLength * hEntity + hDBF->nHeaderLength;
fseek( hDBF->fp, nRecordOffset, 0 );
fread( hDBF->pszCurrentRecord, hDBF->nRecordLength, 1, hDBF->fp );
hDBF->nCurrentRecord = hEntity;
}
pabyRec = (uchar *) hDBF->pszCurrentRecord;
/* -------------------------------------------------------------------- */
/* Assign all the record fields. */
/* -------------------------------------------------------------------- */
switch( hDBF->pachFieldType[iField] )
{
case 'D':
case 'N':
if( hDBF->panFieldDecimals[iField] == 0 )
{
sprintf( szFormat, "%%%dd", hDBF->panFieldSize[iField] );
sprintf(szSField, szFormat, (int) *((double *) pValue) );
if( (int) strlen(szSField) > hDBF->panFieldSize[iField] )
szSField[hDBF->panFieldSize[iField]] = '\0';
strncpy((char *) (pabyRec+hDBF->panFieldOffset[iField]),
szSField, strlen(szSField) );
}
else
{
sprintf( szFormat, "%%%d.%df",
hDBF->panFieldSize[iField],
hDBF->panFieldDecimals[iField] );
sprintf(szSField, szFormat, *((double *) pValue) );
if( (int) strlen(szSField) > hDBF->panFieldSize[iField] )
szSField[hDBF->panFieldSize[iField]] = '\0';
strncpy((char *) (pabyRec+hDBF->panFieldOffset[iField]),
szSField, strlen(szSField) );
}
break;
default:
if( (int) strlen((char *) pValue) > hDBF->panFieldSize[iField] )
{
int iben = strlen((char *) pValue);
char szTemp[255];
strncpy(szTemp, (char *) pValue, 253);
szTemp[253] = '\0';
strcat(szTemp, "*");
strcpy((char *) pValue, szTemp);
j = hDBF->panFieldSize[iField];
}
else
j = strlen((char *) pValue);
strncpy((char *) (pabyRec+hDBF->panFieldOffset[iField]),
(char *) pValue, j );
break;
}
hDBF->bCurrentRecordModified = TRUE;
hDBF->bUpdated = TRUE;
return( TRUE );
}
