The R Project SVN
R-packages
(root)/trunk/foreign/src/dbfopen.c – Rev 4918
Rev 665 | Rev 5040 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed
/******************************************************************************** Project: Shapelib* Purpose: Implementation of .dbf access API documented in dbf_api.html.* Author: Frank Warmerdam, warmerdam@pobox.com******************************************************************************** Copyright (c) 1999, Frank Warmerdam** This software is available under the following "MIT Style" license,* or at the option of the licensee under the LGPL (see LICENSE.LGPL). This* option is discussed in more detail in shapelib.html.** --** Permission is hereby granted, free of charge, to any person obtaining a* copy of this software and associated documentation files (the "Software"),* to deal in the Software without restriction, including without limitation* the rights to use, copy, modify, merge, publish, distribute, sublicense,* and/or sell copies of the Software, and to permit persons to whom the* Software is furnished to do so, subject to the following conditions:** The above copyright notice and this permission notice shall be included* in all copies or substantial portions of the Software.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER* DEALINGS IN THE SOFTWARE.******************************************************************************** Revision 1.50 2003/04/21 18:58:25 warmerda* ensure current record is flushed at same time as header is updated** Revision 1.49 2003/04/21 18:30:37 warmerda* added header write/update public methods** Revision 1.48 2003/03/10 14:51:27 warmerda* DBFWrite* calls now return FALSE if they have to truncate** Revision 1.47 2002/11/20 03:32:22 warmerda* Ensure field name in DBFGetFieldIndex() is properly terminated.** Revision 1.46 2002/10/09 13:10:21 warmerda* Added check that width is positive.** Revision 1.45 2002/09/29 00:00:08 warmerda* added FTLogical and logical attribute read/write calls** Revision 1.44 2002/05/07 13:46:11 warmerda* Added DBFWriteAttributeDirectly().** Revision 1.43 2002/02/13 19:39:21 warmerda* Fix casting issues in DBFCloneEmpty().** Revision 1.42 2002/01/15 14:36:07 warmerda* updated email address** Revision 1.41 2002/01/15 14:31:49 warmerda* compute rather than copying nHeaderLength in DBFCloneEmpty()** Revision 1.40 2002/01/09 04:32:35 warmerda* fixed to read correct amount of header** Revision 1.39 2001/12/11 22:41:03 warmerda* improve io related error checking when reading header** Revision 1.38 2001/11/28 16:07:31 warmerda* Cleanup to avoid compiler warnings as suggested by Richard Hash.** Revision 1.37 2001/07/04 05:18:09 warmerda* do last fix properly** Revision 1.36 2001/07/04 05:16:09 warmerda* fixed fieldname comparison in DBFGetFieldIndex** Revision 1.35 2001/06/22 02:10:06 warmerda* fixed NULL shape support with help from Jim Matthews** Revision 1.33 2001/05/31 19:20:13 warmerda* added DBFGetFieldIndex()** Revision 1.32 2001/05/31 18:15:40 warmerda* Added support for NULL fields in DBF files** Revision 1.31 2001/05/23 13:36:52 warmerda* added use of SHPAPI_CALL** Revision 1.30 2000/12/05 14:43:38 warmerda* DBReadAttribute() white space trimming bug fix** Revision 1.29 2000/10/05 14:36:44 warmerda* fix bug with writing very wide numeric fields** Revision 1.28 2000/09/25 14:18:07 warmerda* Added some casts of strlen() return result to fix warnings on some* systems, as submitted by Daniel.** Revision 1.27 2000/09/25 14:15:51 warmerda* added DBFGetNativeFieldType()** Revision 1.26 2000/07/07 13:39:45 warmerda* removed unused variables, and added system include files** Revision 1.25 2000/05/29 18:19:13 warmerda* avoid use of uchar, and adding casting fix** Revision 1.24 2000/05/23 13:38:27 warmerda* Added error checks on return results of fread() and fseek().** Revision 1.23 2000/05/23 13:25:49 warmerda* Avoid crashing if field or record are out of range in dbfread*attribute().** Revision 1.22 1999/12/15 13:47:24 warmerda* Added stdlib.h to ensure that atof() is prototyped.** Revision 1.21 1999/12/13 17:25:46 warmerda* Added support for upper case .DBF extention.** Revision 1.20 1999/11/30 16:32:11 warmerda* Use atof() instead of sscanf().** Revision 1.19 1999/11/05 14:12:04 warmerda* updated license terms** Revision 1.18 1999/07/27 00:53:28 warmerda* ensure that whole old field value clear on write of string** Revision 1.1 1999/07/05 18:58:07 warmerda* New** Revision 1.17 1999/06/11 19:14:12 warmerda* Fixed some memory leaks.** Revision 1.16 1999/06/11 19:04:11 warmerda* Remoted some unused variables.** Revision 1.15 1999/05/11 03:19:28 warmerda* added new Tuple api, and improved extension handling - add from candrsn** Revision 1.14 1999/05/04 15:01:48 warmerda* Added 'F' support.** Revision 1.13 1999/03/23 17:38:59 warmerda* DBFAddField() now actually does return the new field number, or -1 if* it fails.** Revision 1.12 1999/03/06 02:54:46 warmerda* Added logic to convert shapefile name to dbf filename in DBFOpen()* for convenience.** Revision 1.11 1998/12/31 15:30:34 warmerda* Improved the interchangability of numeric and string attributes. Add* white space trimming option for attributes.** Revision 1.10 1998/12/03 16:36:44 warmerda* Use r+b instead of rb+ for binary access.** Revision 1.9 1998/12/03 15:34:23 warmerda* Updated copyright message.** Revision 1.8 1997/12/04 15:40:15 warmerda* Added newline character after field definitions.** Revision 1.7 1997/03/06 14:02:10 warmerda* Ensure bUpdated is initialized.** Revision 1.6 1996/02/12 04:54:41 warmerda* Ensure that DBFWriteAttribute() returns TRUE if it succeeds.** Revision 1.5 1995/10/21 03:15:12 warmerda* Changed to use binary file access, and ensure that the* field name field is zero filled, and limited to 10 chars.** Revision 1.4 1995/08/24 18:10:42 warmerda* Added use of SfRealloc() to avoid pre-ANSI realloc() functions such* as on the Sun.** Revision 1.3 1995/08/04 03:15:16 warmerda* Fixed up header.** Revision 1.2 1995/08/04 03:14:43 warmerda* Added header.*/#include "shapefil.h"#include <R_ext/Arith.h> /* for NA_INTEGER, NA_REAL */#include <math.h>#include <stdlib.h>#include <ctype.h>#include <string.h>#ifndef FALSE# define FALSE 0# define TRUE 1#endifstatic int nStringFieldLen = 0;static char * pszStringField = NULL;/************************************************************************//* SfRealloc() *//* *//* A realloc cover function that will access a NULL pointer as *//* a valid input. *//************************************************************************/static void * SfRealloc( void * pMem, int nNewSize ){if( pMem == NULL )return( (void *) malloc(nNewSize) );elsereturn( (void *) realloc(pMem,nNewSize) );}/************************************************************************//* DBFWriteHeader() *//* *//* This is called to write out the file header, and field *//* descriptions before writing any actual data records. This *//* also computes all the DBFDataSet field offset/size/decimals *//* and so forth values. *//************************************************************************/static void DBFWriteHeader(DBFHandle psDBF){unsigned char abyHeader[XBASE_FLDHDR_SZ];int i;if( !psDBF->bNoHeader )return;psDBF->bNoHeader = FALSE;/* -------------------------------------------------------------------- *//* Initialize the file header information. *//* -------------------------------------------------------------------- */for( i = 0; i < XBASE_FLDHDR_SZ; i++ )abyHeader[i] = 0;abyHeader[0] = 0x03; /* memo field? - just copying *//* write out a dummy date */abyHeader[1] = 95; /* YY */abyHeader[2] = 7; /* MM */abyHeader[3] = 26; /* DD *//* record count preset at zero */abyHeader[8] = psDBF->nHeaderLength % 256;abyHeader[9] = psDBF->nHeaderLength / 256;abyHeader[10] = psDBF->nRecordLength % 256;abyHeader[11] = psDBF->nRecordLength / 256;/* -------------------------------------------------------------------- *//* Write the initial 32 byte file header, and all the field *//* descriptions. *//* -------------------------------------------------------------------- */fseek( psDBF->fp, 0, 0 );fwrite( abyHeader, XBASE_FLDHDR_SZ, 1, psDBF->fp );fwrite( psDBF->pszHeader, XBASE_FLDHDR_SZ, psDBF->nFields, psDBF->fp );/* -------------------------------------------------------------------- *//* Write out the newline character if there is room for it. *//* -------------------------------------------------------------------- */if( psDBF->nHeaderLength > 32*psDBF->nFields + 32 ){char cNewline;cNewline = 0x0d;fwrite( &cNewline, 1, 1, psDBF->fp );}}/************************************************************************//* DBFFlushRecord() *//* *//* Write out the current record if there is one. *//************************************************************************/static void DBFFlushRecord( DBFHandle psDBF ){int nRecordOffset;if( psDBF->bCurrentRecordModified && psDBF->nCurrentRecord > -1 ){psDBF->bCurrentRecordModified = FALSE;nRecordOffset = psDBF->nRecordLength * psDBF->nCurrentRecord+ psDBF->nHeaderLength;fseek( psDBF->fp, nRecordOffset, 0 );fwrite( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );}}/************************************************************************//* DBFUpdateHeader() *//************************************************************************/void SHPAPI_CALLDBFUpdateHeader( DBFHandle psDBF ){unsigned char abyFileHeader[32];if( psDBF->bNoHeader )DBFWriteHeader( psDBF );DBFFlushRecord( psDBF );fseek( psDBF->fp, 0, 0 );fread( abyFileHeader, 32, 1, psDBF->fp );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 );fflush( psDBF->fp );}/************************************************************************//* DBFOpen() *//* *//* Open a .dbf file. *//************************************************************************/DBFHandle SHPAPI_CALLDBFOpen( const char * pszFilename, const char * pszAccess ){DBFHandle psDBF;unsigned char *pabyBuf;int nFields, nHeadLen, nRecLen, iField, i;char *pszBasename, *pszFullname;/* -------------------------------------------------------------------- *//* 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 = fopen( pszFullname, pszAccess );if( psDBF->fp == NULL ){sprintf( pszFullname, "%s.DBF", pszBasename );psDBF->fp = fopen(pszFullname, pszAccess );}free( pszBasename );free( pszFullname );if( psDBF->fp == NULL ){free( psDBF );return( NULL );}psDBF->bNoHeader = FALSE;psDBF->nCurrentRecord = -1;psDBF->bCurrentRecordModified = FALSE;/* -------------------------------------------------------------------- *//* Read Table Header info *//* -------------------------------------------------------------------- */pabyBuf = (unsigned char *) malloc(500);if( fread( pabyBuf, 32, 1, psDBF->fp ) != 1 ){fclose( psDBF->fp );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 = nRecLen = pabyBuf[10] + pabyBuf[11]*256;psDBF->nFields = nFields = (nHeadLen - 32) / 32;psDBF->pszCurrentRecord = (char *) malloc(nRecLen);/* -------------------------------------------------------------------- *//* Read in Field Definitions *//* -------------------------------------------------------------------- */pabyBuf = (unsigned char *) SfRealloc(pabyBuf,nHeadLen);psDBF->pszHeader = (char *) pabyBuf;fseek( psDBF->fp, 32, 0 );if( fread( pabyBuf, nHeadLen-32, 1, psDBF->fp ) != 1 ){fclose( psDBF->fp );free( pabyBuf );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] + pabyFInfo[17]*256;psDBF->panFieldDecimals[iField] = 0;}psDBF->pachFieldType[iField] = (char) pabyFInfo[11];if( iField == 0 )psDBF->panFieldOffset[iField] = 1;elsepsDBF->panFieldOffset[iField] =psDBF->panFieldOffset[iField-1] + psDBF->panFieldSize[iField-1];}return( psDBF );}/************************************************************************//* DBFClose() *//************************************************************************/void SHPAPI_CALLDBFClose(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;}}/************************************************************************//* DBFCreate() *//* *//* Create a new .dbf file. *//************************************************************************/DBFHandle SHPAPI_CALLDBFCreate( const char * pszFilename ){DBFHandle psDBF;FILE *fp;char *pszFullname, *pszBasename;int i;/* -------------------------------------------------------------------- *//* 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 );free( pszBasename );/* -------------------------------------------------------------------- *//* Create the file. *//* -------------------------------------------------------------------- */fp = fopen( pszFullname, "wb" );if( fp == NULL )return( NULL );fputc( 0, fp );fclose( fp );fp = fopen( pszFullname, "rb+" );if( fp == NULL )return( NULL );free( pszFullname );/* -------------------------------------------------------------------- *//* Create the info structure. *//* -------------------------------------------------------------------- */psDBF = (DBFHandle) malloc(sizeof(DBFInfo));psDBF->fp = fp;psDBF->nRecords = 0;psDBF->nFields = 0;psDBF->nRecordLength = 1;psDBF->nHeaderLength = 33;psDBF->panFieldOffset = NULL;psDBF->panFieldSize = NULL;psDBF->panFieldDecimals = NULL;psDBF->pachFieldType = NULL;psDBF->pszHeader = NULL;psDBF->nCurrentRecord = -1;psDBF->bCurrentRecordModified = FALSE;psDBF->pszCurrentRecord = NULL;psDBF->bNoHeader = TRUE;return( psDBF );}/************************************************************************//* DBFAddField() *//* *//* Add a field to a newly created .dbf file before any records *//* are written. *//************************************************************************/int SHPAPI_CALLDBFAddField(DBFHandle psDBF, const char * pszFieldName,DBFFieldType eType, int nWidth, int nDecimals ){char *pszFInfo;int i;/* -------------------------------------------------------------------- *//* Do some checking to ensure we can add records to this file. *//* -------------------------------------------------------------------- */if( psDBF->nRecords > 0 )return( -1 );if( !psDBF->bNoHeader )return( -1 );if( eType != FTDouble && nDecimals != 0 )return( -1 );if( nWidth < 1 )return -1;/* -------------------------------------------------------------------- *//* SfRealloc all the arrays larger to hold the additional field *//* information. *//* -------------------------------------------------------------------- */psDBF->nFields++;psDBF->panFieldOffset = (int *)SfRealloc( psDBF->panFieldOffset, sizeof(int) * psDBF->nFields );psDBF->panFieldSize = (int *)SfRealloc( psDBF->panFieldSize, sizeof(int) * psDBF->nFields );psDBF->panFieldDecimals = (int *)SfRealloc( psDBF->panFieldDecimals, sizeof(int) * psDBF->nFields );psDBF->pachFieldType = (char *)SfRealloc( psDBF->pachFieldType, sizeof(char) * psDBF->nFields );/* -------------------------------------------------------------------- *//* Assign the new field information fields. *//* -------------------------------------------------------------------- */psDBF->panFieldOffset[psDBF->nFields-1] = psDBF->nRecordLength;psDBF->nRecordLength += nWidth;psDBF->panFieldSize[psDBF->nFields-1] = nWidth;psDBF->panFieldDecimals[psDBF->nFields-1] = nDecimals;if( eType == FTLogical )psDBF->pachFieldType[psDBF->nFields-1] = 'L';else if( eType == FTString )psDBF->pachFieldType[psDBF->nFields-1] = 'C';else if( eType == FTDate )psDBF->pachFieldType[psDBF->nFields-1] = 'D';elsepsDBF->pachFieldType[psDBF->nFields-1] = 'N';/* -------------------------------------------------------------------- *//* Extend the required header information. *//* -------------------------------------------------------------------- */psDBF->nHeaderLength += 32;psDBF->bUpdated = FALSE;psDBF->pszHeader = (char *) SfRealloc(psDBF->pszHeader,psDBF->nFields*32);pszFInfo = psDBF->pszHeader + 32 * (psDBF->nFields-1);for( i = 0; i < 32; i++ )pszFInfo[i] = '\0';if( (int) strlen(pszFieldName) < 10 )strncpy( pszFInfo, pszFieldName, strlen(pszFieldName));elsestrncpy( pszFInfo, pszFieldName, 10);pszFInfo[11] = psDBF->pachFieldType[psDBF->nFields-1];if( eType == FTString ){pszFInfo[16] = nWidth % 256;pszFInfo[17] = nWidth / 256;}else{pszFInfo[16] = nWidth;pszFInfo[17] = nDecimals;}/* -------------------------------------------------------------------- *//* Make the current record buffer appropriately larger. *//* -------------------------------------------------------------------- */psDBF->pszCurrentRecord = (char *) SfRealloc(psDBF->pszCurrentRecord,psDBF->nRecordLength);return( psDBF->nFields-1 );}/************************************************************************//* DBFReadAttribute() *//* *//* Read one of the attribute fields of a record. *//************************************************************************/static void *DBFReadAttribute(DBFHandle psDBF, int hEntity, int iField,char chReqType ){int nRecordOffset;unsigned char *pabyRec;void *pReturnField = NULL;static double dDoubleField;/* -------------------------------------------------------------------- *//* Verify selection. *//* -------------------------------------------------------------------- */if( hEntity < 0 || hEntity >= psDBF->nRecords )return( NULL );if( iField < 0 || iField >= psDBF->nFields )return( NULL );/* -------------------------------------------------------------------- *//* Have we read the record? *//* -------------------------------------------------------------------- */if( psDBF->nCurrentRecord != hEntity ){DBFFlushRecord( psDBF );nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;if( fseek( psDBF->fp, nRecordOffset, 0 ) != 0 ){fprintf( stderr, "fseek(%d) failed on DBF file.\n",nRecordOffset );return NULL;}if( fread( psDBF->pszCurrentRecord, psDBF->nRecordLength,1, psDBF->fp ) != 1 ){fprintf( stderr, "fread(%d) failed on DBF file.\n",psDBF->nRecordLength );return NULL;}psDBF->nCurrentRecord = hEntity;}pabyRec = (unsigned char *) 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' ){dDoubleField = atof(pszStringField);pReturnField = &dDoubleField;}/* -------------------------------------------------------------------- *//* Should we trim white space off the string attribute value? *//* -------------------------------------------------------------------- */#ifdef TRIM_DBF_WHITESPACEelse{char *pchSrc, *pchDst;pchDst = pchSrc = pszStringField;while( *pchSrc == ' ' )pchSrc++;while( *pchSrc != '\0' )*(pchDst++) = *(pchSrc++);*pchDst = '\0';while( pchDst != pszStringField && *(--pchDst) == ' ' )*pchDst = '\0';}#endifreturn( pReturnField );}/************************************************************************//* DBFReadIntAttribute() *//* *//* Read an integer attribute. *//************************************************************************/int SHPAPI_CALLDBFReadIntegerAttribute( DBFHandle psDBF, int iRecord, int iField ){double *pdValue;pdValue = (double *) DBFReadAttribute( psDBF, iRecord, iField, 'N' );if( pdValue == NULL )return NA_INTEGER;elsereturn( (int) *pdValue );}/************************************************************************//* DBFReadDoubleAttribute() *//* *//* Read a double attribute. *//************************************************************************/double SHPAPI_CALLDBFReadDoubleAttribute( DBFHandle psDBF, int iRecord, int iField ){double *pdValue;pdValue = (double *) DBFReadAttribute( psDBF, iRecord, iField, 'N' );if( pdValue == NULL )return NA_REAL;elsereturn( *pdValue );}/************************************************************************//* DBFReadStringAttribute() *//* *//* Read a string attribute. *//************************************************************************/const char SHPAPI_CALL1(*)DBFReadStringAttribute( DBFHandle psDBF, int iRecord, int iField ){return( (const char *) DBFReadAttribute( psDBF, iRecord, iField, 'C' ) );}/************************************************************************//* DBFReadLogicalAttribute() *//* *//* Read a logical attribute. *//************************************************************************/const char SHPAPI_CALL1(*)DBFReadLogicalAttribute( DBFHandle psDBF, int iRecord, int iField ){return( (const char *) DBFReadAttribute( psDBF, iRecord, iField, 'L' ) );}/************************************************************************//* DBFIsAttributeNULL() *//* *//* Return TRUE if value for field is NULL. *//* *//* Contributed by Jim Matthews. *//************************************************************************/int SHPAPI_CALLDBFIsAttributeNULL( DBFHandle psDBF, int iRecord, int iField ){const char *pszValue;pszValue = DBFReadStringAttribute( psDBF, iRecord, iField );switch(psDBF->pachFieldType[iField]){case 'N':case 'F':/* NULL numeric fields have value "****************" */return strlen(pszValue) == 0 || pszValue[0] == '*';case 'D':/* NULL date fields have value "00000000" */return strlen(pszValue) == 0 || strncmp(pszValue,"00000000",8) == 0;case 'L':/* NULL boolean fields have value "?" */return pszValue[0] == '?';default:/* empty string fields are considered NULL */return strlen(pszValue) == 0;}}/************************************************************************//* DBFGetFieldCount() *//* *//* Return the number of fields in this table. *//************************************************************************/int SHPAPI_CALLDBFGetFieldCount( DBFHandle psDBF ){return( psDBF->nFields );}/************************************************************************//* DBFGetRecordCount() *//* *//* Return the number of records in this table. *//************************************************************************/int SHPAPI_CALLDBFGetRecordCount( DBFHandle psDBF ){return( psDBF->nRecords );}/************************************************************************//* DBFGetFieldInfo() *//* *//* Return any requested information about the field. *//************************************************************************/DBFFieldType SHPAPI_CALLDBFGetFieldInfo( DBFHandle psDBF, int iField, char * pszFieldName,int * pnWidth, int * pnDecimals ){if( iField < 0 || iField >= psDBF->nFields )return( FTInvalid );if( pnWidth != NULL )*pnWidth = psDBF->panFieldSize[iField];if( pnDecimals != NULL )*pnDecimals = psDBF->panFieldDecimals[iField];if( pszFieldName != NULL ){int i;strncpy( pszFieldName, (char *) psDBF->pszHeader+iField*32, 11 );pszFieldName[11] = '\0';for( i = 10; i > 0 && pszFieldName[i] == ' '; i-- )pszFieldName[i] = '\0';}if ( psDBF->pachFieldType[iField] == 'L' )return( FTLogical);else if( psDBF->pachFieldType[iField] == 'N'|| psDBF->pachFieldType[iField] == 'F' )/* || psDBF->pachFieldType[iField] == 'D' ) D is Date */{if( psDBF->panFieldDecimals[iField] > 0 )return( FTDouble );elsereturn( FTInteger );}else{return( FTString );}}/************************************************************************//* DBFWriteAttribute() *//* *//* Write an attribute record to the file. *//************************************************************************/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 );fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );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 );}/************************************************************************//* DBFWriteAttributeDirectly() *//* *//* Write an attribute record to the file, but without any *//* reformatting based on type. The provided buffer is written *//* as is to the field position in the record. *//************************************************************************/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 );fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );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 );}/************************************************************************//* DBFWriteDoubleAttribute() *//* *//* Write a double attribute. *//************************************************************************/int SHPAPI_CALLDBFWriteDoubleAttribute( DBFHandle psDBF, int iRecord, int iField,double dValue ){return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) &dValue ) );}/************************************************************************//* DBFWriteIntegerAttribute() *//* *//* Write a integer attribute. *//************************************************************************/int SHPAPI_CALLDBFWriteIntegerAttribute( DBFHandle psDBF, int iRecord, int iField,int nValue ){double dValue = nValue;return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) &dValue ) );}/************************************************************************//* DBFWriteStringAttribute() *//* *//* Write a string attribute. *//************************************************************************/int SHPAPI_CALLDBFWriteStringAttribute( DBFHandle psDBF, int iRecord, int iField,const char * pszValue ){return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) pszValue ) );}/************************************************************************//* DBFWriteNULLAttribute() *//* *//* Write a string attribute. *//************************************************************************/int SHPAPI_CALLDBFWriteNULLAttribute( DBFHandle psDBF, int iRecord, int iField ){return( DBFWriteAttribute( psDBF, iRecord, iField, NULL ) );}/************************************************************************//* DBFWriteLogicalAttribute() *//* *//* Write a logical attribute. *//************************************************************************/int SHPAPI_CALLDBFWriteLogicalAttribute( DBFHandle psDBF, int iRecord, int iField,const char lValue){return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) (&lValue) ) );}/************************************************************************//* DBFWriteTuple() *//* *//* Write an attribute record to the file. *//************************************************************************/int SHPAPI_CALLDBFWriteTuple(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 );fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );psDBF->nCurrentRecord = hEntity;}pabyRec = (unsigned char *) psDBF->pszCurrentRecord;memcpy ( pabyRec, pRawTuple, psDBF->nRecordLength );psDBF->bCurrentRecordModified = TRUE;psDBF->bUpdated = TRUE;return( TRUE );}/************************************************************************//* DBFReadTuple() *//* *//* Read one of the attribute fields of a record. *//************************************************************************/const char SHPAPI_CALL1(*)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 );fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );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 );}/************************************************************************//* DBFCloneEmpty() *//* *//* Read one of the attribute fields of a record. *//************************************************************************/DBFHandle SHPAPI_CALLDBFCloneEmpty(DBFHandle psDBF, const char * pszFilename ){DBFHandle newDBF;newDBF = DBFCreate ( pszFilename );if ( newDBF == NULL ) return ( NULL );newDBF->pszHeader = (char *) malloc ( 32 * psDBF->nFields );memcpy ( newDBF->pszHeader, psDBF->pszHeader, 32 * psDBF->nFields );newDBF->nFields = psDBF->nFields;newDBF->nRecordLength = psDBF->nRecordLength;newDBF->nHeaderLength = 32 * (psDBF->nFields+1);newDBF->panFieldOffset = (int *) malloc ( sizeof(int) * psDBF->nFields );memcpy ( newDBF->panFieldOffset, psDBF->panFieldOffset, sizeof(int) * psDBF->nFields );newDBF->panFieldSize = (int *) malloc ( sizeof(int) * psDBF->nFields );memcpy ( newDBF->panFieldSize, psDBF->panFieldSize, sizeof(int) * psDBF->nFields );newDBF->panFieldDecimals = (int *) malloc ( sizeof(int) * psDBF->nFields );memcpy ( newDBF->panFieldDecimals, psDBF->panFieldDecimals, sizeof(int) * psDBF->nFields );newDBF->pachFieldType = (char *) malloc ( sizeof(int) * psDBF->nFields );memcpy ( newDBF->pachFieldType, psDBF->pachFieldType, sizeof(int) * psDBF->nFields );newDBF->bNoHeader = TRUE;newDBF->bUpdated = TRUE;DBFWriteHeader ( newDBF );DBFClose ( newDBF );newDBF = DBFOpen ( pszFilename, "rb+" );return ( newDBF );}/************************************************************************//* DBFGetNativeFieldType() *//* *//* Return the DBase field type for the specified field. *//* *//* Value can be one of: 'C' (String), 'D' (Date), 'F' (Float), *//* 'N' (Numeric, with or without decimal), *//* 'L' (Logical), *//* 'M' (Memo: 10 digits .DBT block ptr) *//************************************************************************/char SHPAPI_CALLDBFGetNativeFieldType( DBFHandle psDBF, int iField ){if( iField >=0 && iField < psDBF->nFields )return psDBF->pachFieldType[iField];return ' ';}/************************************************************************//* str_to_upper() *//************************************************************************/static void str_to_upper (char *string){int len;short i = -1;len = strlen (string);while (++i < len)if (isalpha((int)string[i]) && islower((int)string[i]))string[i] = toupper ((int)string[i]);}/************************************************************************//* DBFGetFieldIndex() *//* *//* Get the index number for a field in a .dbf file. *//* *//* Contributed by Jim Matthews. *//************************************************************************/int SHPAPI_CALLDBFGetFieldIndex(DBFHandle psDBF, const char *pszFieldName){char name[12], name1[12], name2[12];int i;strncpy(name1, pszFieldName,11);name1[11] = '\0';str_to_upper(name1);for( i = 0; i < DBFGetFieldCount(psDBF); i++ ){DBFGetFieldInfo( psDBF, i, name, NULL, NULL );strncpy(name2,name,11);str_to_upper(name2);if(!strncmp(name1,name2,10))return(i);}return(-1);}