1
/******************************************************************************
2
* $Id: dbfopen.c,v 1.89 2011-07-24 05:59:25 fwarmerdam Exp $
5
* Purpose: Implementation of .dbf access API documented in dbf_api.html.
6
* Author: Frank Warmerdam, warmerdam@pobox.com
8
******************************************************************************
9
* Copyright (c) 1999, Frank Warmerdam
11
* This software is available under the following "MIT Style" license,
12
* or at the option of the licensee under the LGPL (see LICENSE.LGPL). This
13
* option is discussed in more detail in shapelib.html.
17
* Permission is hereby granted, free of charge, to any person obtaining a
18
* copy of this software and associated documentation files (the "Software"),
19
* to deal in the Software without restriction, including without limitation
20
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
21
* and/or sell copies of the Software, and to permit persons to whom the
22
* Software is furnished to do so, subject to the following conditions:
24
* The above copyright notice and this permission notice shall be included
25
* in all copies or substantial portions of the Software.
27
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
28
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
30
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
31
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
32
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
33
* DEALINGS IN THE SOFTWARE.
34
******************************************************************************
37
* Revision 1.89 2011-07-24 05:59:25 fwarmerdam
38
* minimize use of CPLError in favor of SAHooks.Error()
40
* Revision 1.88 2011-05-13 17:35:17 fwarmerdam
41
* added DBFReorderFields() and DBFAlterFields() functions (from Even)
43
* Revision 1.87 2011-05-07 22:41:02 fwarmerdam
44
* ensure pending record is flushed when adding a native field (GDAL #4073)
46
* Revision 1.86 2011-04-17 15:15:29 fwarmerdam
47
* Removed unused variable.
49
* Revision 1.85 2010-12-06 16:09:34 fwarmerdam
50
* fix buffer read overrun fetching code page (bug 2276)
52
* Revision 1.84 2009-10-29 19:59:48 fwarmerdam
53
* avoid crash on truncated header (gdal #3093)
55
* Revision 1.83 2008/11/12 14:28:15 fwarmerdam
56
* DBFCreateField() now works on files with records
58
* Revision 1.82 2008/11/11 17:47:09 fwarmerdam
59
* added DBFDeleteField() function
61
* Revision 1.81 2008/01/03 17:48:13 bram
62
* in DBFCreate, use default code page LDID/87 (= 0x57, ANSI)
63
* instead of LDID/3. This seems to be the same as what ESRI
64
* would be doing by default.
66
* Revision 1.80 2007/12/30 14:36:39 fwarmerdam
67
* avoid syntax issue with last comment.
69
* Revision 1.79 2007/12/30 14:35:48 fwarmerdam
70
* Avoid char* / unsigned char* warnings.
72
* Revision 1.78 2007/12/18 18:28:07 bram
73
* - create hook for client specific atof (bugzilla ticket 1615)
74
* - check for NULL handle before closing cpCPG file, and close after reading.
76
* Revision 1.77 2007/12/15 20:25:21 bram
77
* dbfopen.c now reads the Code Page information from the DBF file, and exports
78
* this information as a string through the DBFGetCodePage function. This is
79
* either the number from the LDID header field ("LDID/<number>") or as the
80
* content of an accompanying .CPG file. When creating a DBF file, the code can
81
* be set using DBFCreateEx.
83
* Revision 1.76 2007/12/12 22:21:32 bram
84
* DBFClose: check for NULL psDBF handle before trying to close it.
86
* Revision 1.75 2007/12/06 13:58:19 fwarmerdam
87
* make sure file offset calculations are done in as SAOffset
89
* Revision 1.74 2007/12/06 07:00:25 fwarmerdam
90
* dbfopen now using SAHooks for fileio
92
* Revision 1.73 2007/09/03 19:48:11 fwarmerdam
93
* move DBFReadAttribute() static dDoubleField into dbfinfo
95
* Revision 1.72 2007/09/03 19:34:06 fwarmerdam
96
* Avoid use of static tuple buffer in DBFReadTuple()
98
* Revision 1.71 2006/06/22 14:37:18 fwarmerdam
99
* avoid memory leak if dbfopen fread fails
101
* Revision 1.70 2006/06/17 17:47:05 fwarmerdam
102
* use calloc() for dbfinfo in DBFCreate
104
* Revision 1.69 2006/06/17 15:34:32 fwarmerdam
105
* disallow creating fields wider than 255
107
* Revision 1.68 2006/06/17 15:12:40 fwarmerdam
108
* Fixed C++ style comments.
110
* Revision 1.67 2006/06/17 00:24:53 fwarmerdam
111
* Don't treat non-zero decimals values as high order byte for length
112
* for strings. It causes serious corruption for some files.
113
* http://bugzilla.remotesensing.org/show_bug.cgi?id=1202
115
* Revision 1.66 2006/03/29 18:26:20 fwarmerdam
116
* fixed bug with size of pachfieldtype in dbfcloneempty
118
* Revision 1.65 2006/02/15 01:14:30 fwarmerdam
119
* added DBFAddNativeFieldType
121
* Revision 1.64 2006/02/09 00:29:04 fwarmerdam
122
* Changed to put spaces into string fields that are NULL as
123
* per http://bugzilla.maptools.org/show_bug.cgi?id=316.
125
* Revision 1.63 2006/01/25 15:35:43 fwarmerdam
126
* check success on DBFFlushRecord
128
* Revision 1.62 2006/01/10 16:28:03 fwarmerdam
129
* Fixed typo in CPLError.
131
* Revision 1.61 2006/01/10 16:26:29 fwarmerdam
132
* Push loading record buffer into DBFLoadRecord.
133
* Implement CPL error reporting if USE_CPL defined.
135
* Revision 1.60 2006/01/05 01:27:27 fwarmerdam
136
* added dbf deletion mark/fetch
138
* Revision 1.59 2005/03/14 15:20:28 fwarmerdam
141
* Revision 1.58 2005/03/14 15:18:54 fwarmerdam
142
* Treat very wide fields with no decimals as double. This is
143
* more than 32bit integer fields.
145
* Revision 1.57 2005/02/10 20:16:54 fwarmerdam
146
* Make the pszStringField buffer for DBFReadAttribute() static char [256]
149
* Revision 1.56 2005/02/10 20:07:56 fwarmerdam
150
* Fixed bug 305 in DBFCloneEmpty() - header length problem.
152
* Revision 1.55 2004/09/26 20:23:46 fwarmerdam
153
* avoid warnings with rcsid and signed/unsigned stuff
155
* Revision 1.54 2004/09/15 16:26:10 fwarmerdam
156
* Treat all blank numeric fields as null too.
159
#include "shapefil.h"
166
SHP_CVSID("$Id: dbfopen.c,v 1.89 2011-07-24 05:59:25 fwarmerdam Exp $")
173
/************************************************************************/
176
/* A realloc cover function that will access a NULL pointer as */
178
/************************************************************************/
180
static void * SfRealloc( void * pMem, int nNewSize )
184
return( (void *) malloc(nNewSize) );
186
return( (void *) realloc(pMem,nNewSize) );
189
/************************************************************************/
190
/* DBFWriteHeader() */
192
/* This is called to write out the file header, and field */
193
/* descriptions before writing any actual data records. This */
194
/* also computes all the DBFDataSet field offset/size/decimals */
195
/* and so forth values. */
196
/************************************************************************/
198
static void DBFWriteHeader(DBFHandle psDBF)
201
unsigned char abyHeader[XBASE_FLDHDR_SZ];
204
if( !psDBF->bNoHeader )
207
psDBF->bNoHeader = FALSE;
209
/* -------------------------------------------------------------------- */
210
/* Initialize the file header information. */
211
/* -------------------------------------------------------------------- */
212
for( i = 0; i < XBASE_FLDHDR_SZ; i++ )
215
abyHeader[0] = 0x03; /* memo field? - just copying */
217
/* write out a dummy date */
218
abyHeader[1] = 95; /* YY */
219
abyHeader[2] = 7; /* MM */
220
abyHeader[3] = 26; /* DD */
222
/* record count preset at zero */
224
abyHeader[8] = (unsigned char) (psDBF->nHeaderLength % 256);
225
abyHeader[9] = (unsigned char) (psDBF->nHeaderLength / 256);
227
abyHeader[10] = (unsigned char) (psDBF->nRecordLength % 256);
228
abyHeader[11] = (unsigned char) (psDBF->nRecordLength / 256);
230
abyHeader[29] = (unsigned char) (psDBF->iLanguageDriver);
232
/* -------------------------------------------------------------------- */
233
/* Write the initial 32 byte file header, and all the field */
235
/* -------------------------------------------------------------------- */
236
psDBF->sHooks.FSeek( psDBF->fp, 0, 0 );
237
psDBF->sHooks.FWrite( abyHeader, XBASE_FLDHDR_SZ, 1, psDBF->fp );
238
psDBF->sHooks.FWrite( psDBF->pszHeader, XBASE_FLDHDR_SZ, psDBF->nFields,
241
/* -------------------------------------------------------------------- */
242
/* Write out the newline character if there is room for it. */
243
/* -------------------------------------------------------------------- */
244
if( psDBF->nHeaderLength > 32*psDBF->nFields + 32 )
249
psDBF->sHooks.FWrite( &cNewline, 1, 1, psDBF->fp );
253
/************************************************************************/
254
/* DBFFlushRecord() */
256
/* Write out the current record if there is one. */
257
/************************************************************************/
259
static int DBFFlushRecord( DBFHandle psDBF )
262
SAOffset nRecordOffset;
264
if( psDBF->bCurrentRecordModified && psDBF->nCurrentRecord > -1 )
266
psDBF->bCurrentRecordModified = FALSE;
269
psDBF->nRecordLength * (SAOffset) psDBF->nCurrentRecord
270
+ psDBF->nHeaderLength;
272
if( psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 ) != 0
273
|| psDBF->sHooks.FWrite( psDBF->pszCurrentRecord,
274
psDBF->nRecordLength,
275
1, psDBF->fp ) != 1 )
278
sprintf( szMessage, "Failure writing DBF record %d.",
279
psDBF->nCurrentRecord );
280
psDBF->sHooks.Error( szMessage );
288
/************************************************************************/
289
/* DBFLoadRecord() */
290
/************************************************************************/
292
static int DBFLoadRecord( DBFHandle psDBF, int iRecord )
295
if( psDBF->nCurrentRecord != iRecord )
297
SAOffset nRecordOffset;
299
if( !DBFFlushRecord( psDBF ) )
303
psDBF->nRecordLength * (SAOffset) iRecord + psDBF->nHeaderLength;
305
if( psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, SEEK_SET ) != 0 )
308
sprintf( szMessage, "fseek(%ld) failed on DBF file.\n",
309
(long) nRecordOffset );
310
psDBF->sHooks.Error( szMessage );
314
if( psDBF->sHooks.FRead( psDBF->pszCurrentRecord,
315
psDBF->nRecordLength, 1, psDBF->fp ) != 1 )
318
sprintf( szMessage, "fread(%d) failed on DBF file.\n",
319
psDBF->nRecordLength );
320
psDBF->sHooks.Error( szMessage );
324
psDBF->nCurrentRecord = iRecord;
330
/************************************************************************/
331
/* DBFUpdateHeader() */
332
/************************************************************************/
335
DBFUpdateHeader( DBFHandle psDBF )
338
unsigned char abyFileHeader[32];
340
if( psDBF->bNoHeader )
341
DBFWriteHeader( psDBF );
343
DBFFlushRecord( psDBF );
345
psDBF->sHooks.FSeek( psDBF->fp, 0, 0 );
346
psDBF->sHooks.FRead( abyFileHeader, 32, 1, psDBF->fp );
348
abyFileHeader[4] = (unsigned char) (psDBF->nRecords % 256);
349
abyFileHeader[5] = (unsigned char) ((psDBF->nRecords/256) % 256);
350
abyFileHeader[6] = (unsigned char) ((psDBF->nRecords/(256*256)) % 256);
351
abyFileHeader[7] = (unsigned char) ((psDBF->nRecords/(256*256*256)) % 256);
353
psDBF->sHooks.FSeek( psDBF->fp, 0, 0 );
354
psDBF->sHooks.FWrite( abyFileHeader, 32, 1, psDBF->fp );
356
psDBF->sHooks.FFlush( psDBF->fp );
359
/************************************************************************/
362
/* Open a .dbf file. */
363
/************************************************************************/
365
DBFHandle SHPAPI_CALL
366
DBFOpen( const char * pszFilename, const char * pszAccess )
371
SASetupDefaultHooks( &sHooks );
373
return DBFOpenLL( pszFilename, pszAccess, &sHooks );
376
/************************************************************************/
379
/* Open a .dbf file. */
380
/************************************************************************/
382
DBFHandle SHPAPI_CALL
383
DBFOpenLL( const char * pszFilename, const char * pszAccess, SAHooks *psHooks )
388
unsigned char *pabyBuf;
389
int nFields, nHeadLen, iField, i;
390
char *pszBasename, *pszFullname;
393
/* -------------------------------------------------------------------- */
394
/* We only allow the access strings "rb" and "r+". */
395
/* -------------------------------------------------------------------- */
396
if( strcmp(pszAccess,"r") != 0 && strcmp(pszAccess,"r+") != 0
397
&& strcmp(pszAccess,"rb") != 0 && strcmp(pszAccess,"rb+") != 0
398
&& strcmp(pszAccess,"r+b") != 0 )
401
if( strcmp(pszAccess,"r") == 0 )
404
if( strcmp(pszAccess,"r+") == 0 )
407
/* -------------------------------------------------------------------- */
408
/* Compute the base (layer) name. If there is any extension */
409
/* on the passed in filename we will strip it off. */
410
/* -------------------------------------------------------------------- */
411
pszBasename = (char *) malloc(strlen(pszFilename)+5);
412
strcpy( pszBasename, pszFilename );
413
for( i = strlen(pszBasename)-1;
414
i > 0 && pszBasename[i] != '.' && pszBasename[i] != '/'
415
&& pszBasename[i] != '\\';
418
if( pszBasename[i] == '.' )
419
pszBasename[i] = '\0';
421
pszFullname = (char *) malloc(strlen(pszBasename) + 5);
422
sprintf( pszFullname, "%s.dbf", pszBasename );
424
psDBF = (DBFHandle) calloc( 1, sizeof(DBFInfo) );
425
psDBF->fp = psHooks->FOpen( pszFullname, pszAccess );
426
memcpy( &(psDBF->sHooks), psHooks, sizeof(SAHooks) );
428
if( psDBF->fp == NULL )
430
sprintf( pszFullname, "%s.DBF", pszBasename );
431
psDBF->fp = psDBF->sHooks.FOpen(pszFullname, pszAccess );
434
sprintf( pszFullname, "%s.cpg", pszBasename );
435
pfCPG = psHooks->FOpen( pszFullname, "r" );
438
sprintf( pszFullname, "%s.CPG", pszBasename );
439
pfCPG = psHooks->FOpen( pszFullname, "r" );
445
if( psDBF->fp == NULL )
448
if( pfCPG ) psHooks->FClose( pfCPG );
452
psDBF->bNoHeader = FALSE;
453
psDBF->nCurrentRecord = -1;
454
psDBF->bCurrentRecordModified = FALSE;
456
/* -------------------------------------------------------------------- */
457
/* Read Table Header info */
458
/* -------------------------------------------------------------------- */
459
pabyBuf = (unsigned char *) malloc(nBufSize);
460
if( psDBF->sHooks.FRead( pabyBuf, 32, 1, psDBF->fp ) != 1 )
462
psDBF->sHooks.FClose( psDBF->fp );
463
if( pfCPG ) psDBF->sHooks.FClose( pfCPG );
470
pabyBuf[4] + pabyBuf[5]*256 + pabyBuf[6]*256*256 + pabyBuf[7]*256*256*256;
472
psDBF->nHeaderLength = nHeadLen = pabyBuf[8] + pabyBuf[9]*256;
473
psDBF->nRecordLength = pabyBuf[10] + pabyBuf[11]*256;
474
psDBF->iLanguageDriver = pabyBuf[29];
478
psDBF->sHooks.FClose( psDBF->fp );
479
if( pfCPG ) psDBF->sHooks.FClose( pfCPG );
485
psDBF->nFields = nFields = (nHeadLen - 32) / 32;
487
psDBF->pszCurrentRecord = (char *) malloc(psDBF->nRecordLength);
489
/* -------------------------------------------------------------------- */
490
/* Figure out the code page from the LDID and CPG */
491
/* -------------------------------------------------------------------- */
493
psDBF->pszCodePage = NULL;
497
memset( pabyBuf, 0, nBufSize);
498
psDBF->sHooks.FRead( pabyBuf, nBufSize - 1, 1, pfCPG );
499
n = strcspn( (char *) pabyBuf, "\n\r" );
503
psDBF->pszCodePage = (char *) malloc(n + 1);
504
memcpy( psDBF->pszCodePage, pabyBuf, n + 1 );
506
psDBF->sHooks.FClose( pfCPG );
508
if( psDBF->pszCodePage == NULL && pabyBuf[29] != 0 )
510
sprintf( (char *) pabyBuf, "LDID/%d", psDBF->iLanguageDriver );
511
psDBF->pszCodePage = (char *) malloc(strlen((char*)pabyBuf) + 1);
512
strcpy( psDBF->pszCodePage, (char *) pabyBuf );
515
/* -------------------------------------------------------------------- */
516
/* Read in Field Definitions */
517
/* -------------------------------------------------------------------- */
519
pabyBuf = (unsigned char *) SfRealloc(pabyBuf,nHeadLen);
520
psDBF->pszHeader = (char *) pabyBuf;
522
psDBF->sHooks.FSeek( psDBF->fp, 32, 0 );
523
if( psDBF->sHooks.FRead( pabyBuf, nHeadLen-32, 1, psDBF->fp ) != 1 )
525
psDBF->sHooks.FClose( psDBF->fp );
527
free( psDBF->pszCurrentRecord );
532
psDBF->panFieldOffset = (int *) malloc(sizeof(int) * nFields);
533
psDBF->panFieldSize = (int *) malloc(sizeof(int) * nFields);
534
psDBF->panFieldDecimals = (int *) malloc(sizeof(int) * nFields);
535
psDBF->pachFieldType = (char *) malloc(sizeof(char) * nFields);
537
for( iField = 0; iField < nFields; iField++ )
539
unsigned char *pabyFInfo;
541
pabyFInfo = pabyBuf+iField*32;
543
if( pabyFInfo[11] == 'N' || pabyFInfo[11] == 'F' )
545
psDBF->panFieldSize[iField] = pabyFInfo[16];
546
psDBF->panFieldDecimals[iField] = pabyFInfo[17];
550
psDBF->panFieldSize[iField] = pabyFInfo[16];
551
psDBF->panFieldDecimals[iField] = 0;
554
** The following seemed to be used sometimes to handle files with long
555
** string fields, but in other cases (such as bug 1202) the decimals field
556
** just seems to indicate some sort of preferred formatting, not very
557
** wide fields. So I have disabled this code. FrankW.
558
psDBF->panFieldSize[iField] = pabyFInfo[16] + pabyFInfo[17]*256;
559
psDBF->panFieldDecimals[iField] = 0;
563
psDBF->pachFieldType[iField] = (char) pabyFInfo[11];
565
psDBF->panFieldOffset[iField] = 1;
567
psDBF->panFieldOffset[iField] =
568
psDBF->panFieldOffset[iField-1] + psDBF->panFieldSize[iField-1];
574
/************************************************************************/
576
/************************************************************************/
579
DBFClose(DBFHandle psDBF)
584
/* -------------------------------------------------------------------- */
585
/* Write out header if not already written. */
586
/* -------------------------------------------------------------------- */
587
if( psDBF->bNoHeader )
588
DBFWriteHeader( psDBF );
590
DBFFlushRecord( psDBF );
592
/* -------------------------------------------------------------------- */
593
/* Update last access date, and number of records if we have */
595
/* -------------------------------------------------------------------- */
596
if( psDBF->bUpdated )
597
DBFUpdateHeader( psDBF );
599
/* -------------------------------------------------------------------- */
600
/* Close, and free resources. */
601
/* -------------------------------------------------------------------- */
602
psDBF->sHooks.FClose( psDBF->fp );
604
if( psDBF->panFieldOffset != NULL )
606
free( psDBF->panFieldOffset );
607
free( psDBF->panFieldSize );
608
free( psDBF->panFieldDecimals );
609
free( psDBF->pachFieldType );
612
if( psDBF->pszWorkField != NULL )
613
free( psDBF->pszWorkField );
615
free( psDBF->pszHeader );
616
free( psDBF->pszCurrentRecord );
617
free( psDBF->pszCodePage );
622
/************************************************************************/
625
/* Create a new .dbf file with default code page LDID/87 (0x57) */
626
/************************************************************************/
628
DBFHandle SHPAPI_CALL
629
DBFCreate( const char * pszFilename )
632
return DBFCreateEx( pszFilename, "LDID/87" ); // 0x57
635
/************************************************************************/
638
/* Create a new .dbf file. */
639
/************************************************************************/
641
DBFHandle SHPAPI_CALL
642
DBFCreateEx( const char * pszFilename, const char* pszCodePage )
647
SASetupDefaultHooks( &sHooks );
649
return DBFCreateLL( pszFilename, pszCodePage , &sHooks );
652
/************************************************************************/
655
/* Create a new .dbf file. */
656
/************************************************************************/
658
DBFHandle SHPAPI_CALL
659
DBFCreateLL( const char * pszFilename, const char * pszCodePage, SAHooks *psHooks )
664
char *pszFullname, *pszBasename;
668
/* -------------------------------------------------------------------- */
669
/* Compute the base (layer) name. If there is any extension */
670
/* on the passed in filename we will strip it off. */
671
/* -------------------------------------------------------------------- */
672
pszBasename = (char *) malloc(strlen(pszFilename)+5);
673
strcpy( pszBasename, pszFilename );
674
for( i = strlen(pszBasename)-1;
675
i > 0 && pszBasename[i] != '.' && pszBasename[i] != '/'
676
&& pszBasename[i] != '\\';
679
if( pszBasename[i] == '.' )
680
pszBasename[i] = '\0';
682
pszFullname = (char *) malloc(strlen(pszBasename) + 5);
683
sprintf( pszFullname, "%s.dbf", pszBasename );
685
/* -------------------------------------------------------------------- */
686
/* Create the file. */
687
/* -------------------------------------------------------------------- */
688
fp = psHooks->FOpen( pszFullname, "wb" );
692
psHooks->FWrite( &chZero, 1, 1, fp );
693
psHooks->FClose( fp );
695
fp = psHooks->FOpen( pszFullname, "rb+" );
700
sprintf( pszFullname, "%s.cpg", pszBasename );
701
if( pszCodePage != NULL )
703
if( strncmp( pszCodePage, "LDID/", 5 ) == 0 )
705
ldid = atoi( pszCodePage + 5 );
707
ldid = -1; // don't use 0 to indicate out of range as LDID/0 is a valid one
711
SAFile fpCPG = psHooks->FOpen( pszFullname, "w" );
712
psHooks->FWrite( (char*) pszCodePage, strlen(pszCodePage), 1, fpCPG );
713
psHooks->FClose( fpCPG );
716
if( pszCodePage == NULL || ldid >= 0 )
718
psHooks->Remove( pszFullname );
724
/* -------------------------------------------------------------------- */
725
/* Create the info structure. */
726
/* -------------------------------------------------------------------- */
727
psDBF = (DBFHandle) calloc(1,sizeof(DBFInfo));
729
memcpy( &(psDBF->sHooks), psHooks, sizeof(SAHooks) );
733
psDBF->nRecordLength = 1;
734
psDBF->nHeaderLength = 33;
736
psDBF->panFieldOffset = NULL;
737
psDBF->panFieldSize = NULL;
738
psDBF->panFieldDecimals = NULL;
739
psDBF->pachFieldType = NULL;
740
psDBF->pszHeader = NULL;
742
psDBF->nCurrentRecord = -1;
743
psDBF->bCurrentRecordModified = FALSE;
744
psDBF->pszCurrentRecord = NULL;
746
psDBF->bNoHeader = TRUE;
748
psDBF->iLanguageDriver = ldid > 0 ? ldid : 0;
749
psDBF->pszCodePage = NULL;
752
psDBF->pszCodePage = (char * ) malloc( strlen(pszCodePage) + 1 );
753
strcpy( psDBF->pszCodePage, pszCodePage );
759
/************************************************************************/
762
/* Add a field to a newly created .dbf or to an existing one */
763
/************************************************************************/
766
DBFAddField(DBFHandle psDBF, const char * pszFieldName,
767
DBFFieldType eType, int nWidth, int nDecimals )
770
char chNativeType = 'C';
772
if( eType == FTLogical )
774
else if( eType == FTString )
779
return DBFAddNativeFieldType( psDBF, pszFieldName, chNativeType,
783
/************************************************************************/
784
/* DBFGetNullCharacter() */
785
/************************************************************************/
787
static char DBFGetNullCharacter(char chType)
803
/************************************************************************/
806
/* Add a field to a newly created .dbf file before any records */
808
/************************************************************************/
811
DBFAddNativeFieldType(DBFHandle psDBF, const char * pszFieldName,
812
char chType, int nWidth, int nDecimals )
817
int nOldRecordLength, nOldHeaderLength;
820
SAOffset nRecordOffset;
822
/* make sure that everything is written in .dbf */
823
if( !DBFFlushRecord( psDBF ) )
826
/* -------------------------------------------------------------------- */
827
/* Do some checking to ensure we can add records to this file. */
828
/* -------------------------------------------------------------------- */
835
nOldRecordLength = psDBF->nRecordLength;
836
nOldHeaderLength = psDBF->nHeaderLength;
838
/* -------------------------------------------------------------------- */
839
/* SfRealloc all the arrays larger to hold the additional field */
841
/* -------------------------------------------------------------------- */
844
psDBF->panFieldOffset = (int *)
845
SfRealloc( psDBF->panFieldOffset, sizeof(int) * psDBF->nFields );
847
psDBF->panFieldSize = (int *)
848
SfRealloc( psDBF->panFieldSize, sizeof(int) * psDBF->nFields );
850
psDBF->panFieldDecimals = (int *)
851
SfRealloc( psDBF->panFieldDecimals, sizeof(int) * psDBF->nFields );
853
psDBF->pachFieldType = (char *)
854
SfRealloc( psDBF->pachFieldType, sizeof(char) * psDBF->nFields );
856
/* -------------------------------------------------------------------- */
857
/* Assign the new field information fields. */
858
/* -------------------------------------------------------------------- */
859
psDBF->panFieldOffset[psDBF->nFields-1] = psDBF->nRecordLength;
860
psDBF->nRecordLength += nWidth;
861
psDBF->panFieldSize[psDBF->nFields-1] = nWidth;
862
psDBF->panFieldDecimals[psDBF->nFields-1] = nDecimals;
863
psDBF->pachFieldType[psDBF->nFields-1] = chType;
865
/* -------------------------------------------------------------------- */
866
/* Extend the required header information. */
867
/* -------------------------------------------------------------------- */
868
psDBF->nHeaderLength += 32;
869
psDBF->bUpdated = FALSE;
871
psDBF->pszHeader = (char *) SfRealloc(psDBF->pszHeader,psDBF->nFields*32);
873
pszFInfo = psDBF->pszHeader + 32 * (psDBF->nFields-1);
875
for( i = 0; i < 32; i++ )
878
if( (int) strlen(pszFieldName) < 10 )
879
strncpy( pszFInfo, pszFieldName, strlen(pszFieldName));
881
strncpy( pszFInfo, pszFieldName, 10);
883
pszFInfo[11] = psDBF->pachFieldType[psDBF->nFields-1];
887
pszFInfo[16] = (unsigned char) (nWidth % 256);
888
pszFInfo[17] = (unsigned char) (nWidth / 256);
892
pszFInfo[16] = (unsigned char) nWidth;
893
pszFInfo[17] = (unsigned char) nDecimals;
896
/* -------------------------------------------------------------------- */
897
/* Make the current record buffer appropriately larger. */
898
/* -------------------------------------------------------------------- */
899
psDBF->pszCurrentRecord = (char *) SfRealloc(psDBF->pszCurrentRecord,
900
psDBF->nRecordLength);
902
/* we're done if dealing with new .dbf */
903
if( psDBF->bNoHeader )
904
return( psDBF->nFields - 1 );
906
/* -------------------------------------------------------------------- */
907
/* For existing .dbf file, shift records */
908
/* -------------------------------------------------------------------- */
911
pszRecord = (char *) malloc(sizeof(char) * psDBF->nRecordLength);
913
chFieldFill = DBFGetNullCharacter(chType);
915
for (i = psDBF->nRecords-1; i >= 0; --i)
917
nRecordOffset = nOldRecordLength * (SAOffset) i + nOldHeaderLength;
920
psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 );
921
psDBF->sHooks.FRead( pszRecord, nOldRecordLength, 1, psDBF->fp );
923
/* set new field's value to NULL */
924
memset(pszRecord + nOldRecordLength, chFieldFill, nWidth);
926
nRecordOffset = psDBF->nRecordLength * (SAOffset) i + psDBF->nHeaderLength;
928
/* move record to the new place*/
929
psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 );
930
psDBF->sHooks.FWrite( pszRecord, psDBF->nRecordLength, 1, psDBF->fp );
936
/* force update of header with new header, record length and new field */
937
psDBF->bNoHeader = TRUE;
938
DBFUpdateHeader( psDBF );
940
psDBF->nCurrentRecord = -1;
941
psDBF->bCurrentRecordModified = FALSE;
943
return( psDBF->nFields-1 );
946
/************************************************************************/
947
/* DBFReadAttribute() */
949
/* Read one of the attribute fields of a record. */
950
/************************************************************************/
952
static void *DBFReadAttribute(DBFHandle psDBF, int hEntity, int iField,
956
unsigned char *pabyRec;
957
void *pReturnField = NULL;
959
/* -------------------------------------------------------------------- */
960
/* Verify selection. */
961
/* -------------------------------------------------------------------- */
962
if( hEntity < 0 || hEntity >= psDBF->nRecords )
965
if( iField < 0 || iField >= psDBF->nFields )
968
/* -------------------------------------------------------------------- */
969
/* Have we read the record? */
970
/* -------------------------------------------------------------------- */
971
if( !DBFLoadRecord( psDBF, hEntity ) )
974
pabyRec = (unsigned char *) psDBF->pszCurrentRecord;
976
/* -------------------------------------------------------------------- */
977
/* Ensure we have room to extract the target field. */
978
/* -------------------------------------------------------------------- */
979
if( psDBF->panFieldSize[iField] >= psDBF->nWorkFieldLength )
981
psDBF->nWorkFieldLength = psDBF->panFieldSize[iField] + 100;
982
if( psDBF->pszWorkField == NULL )
983
psDBF->pszWorkField = (char *) malloc(psDBF->nWorkFieldLength);
985
psDBF->pszWorkField = (char *) realloc(psDBF->pszWorkField,
986
psDBF->nWorkFieldLength);
989
/* -------------------------------------------------------------------- */
990
/* Extract the requested field. */
991
/* -------------------------------------------------------------------- */
992
strncpy( psDBF->pszWorkField,
993
((const char *) pabyRec) + psDBF->panFieldOffset[iField],
994
psDBF->panFieldSize[iField] );
995
psDBF->pszWorkField[psDBF->panFieldSize[iField]] = '\0';
997
pReturnField = psDBF->pszWorkField;
999
/* -------------------------------------------------------------------- */
1000
/* Decode the field. */
1001
/* -------------------------------------------------------------------- */
1002
if( chReqType == 'N' )
1004
psDBF->dfDoubleField = psDBF->sHooks.Atof(psDBF->pszWorkField);
1006
pReturnField = &(psDBF->dfDoubleField);
1009
/* -------------------------------------------------------------------- */
1010
/* Should we trim white space off the string attribute value? */
1011
/* -------------------------------------------------------------------- */
1012
#ifdef TRIM_DBF_WHITESPACE
1015
char *pchSrc, *pchDst;
1017
pchDst = pchSrc = psDBF->pszWorkField;
1018
while( *pchSrc == ' ' )
1021
while( *pchSrc != '\0' )
1022
*(pchDst++) = *(pchSrc++);
1025
while( pchDst != psDBF->pszWorkField && *(--pchDst) == ' ' )
1030
return( pReturnField );
1033
/************************************************************************/
1034
/* DBFReadIntAttribute() */
1036
/* Read an integer attribute. */
1037
/************************************************************************/
1040
DBFReadIntegerAttribute( DBFHandle psDBF, int iRecord, int iField )
1045
pdValue = (double *) DBFReadAttribute( psDBF, iRecord, iField, 'N' );
1047
if( pdValue == NULL )
1050
return( (int) *pdValue );
1053
/************************************************************************/
1054
/* DBFReadDoubleAttribute() */
1056
/* Read a double attribute. */
1057
/************************************************************************/
1060
DBFReadDoubleAttribute( DBFHandle psDBF, int iRecord, int iField )
1065
pdValue = (double *) DBFReadAttribute( psDBF, iRecord, iField, 'N' );
1067
if( pdValue == NULL )
1073
/************************************************************************/
1074
/* DBFReadStringAttribute() */
1076
/* Read a string attribute. */
1077
/************************************************************************/
1079
const char SHPAPI_CALL1(*)
1080
DBFReadStringAttribute( DBFHandle psDBF, int iRecord, int iField )
1083
return( (const char *) DBFReadAttribute( psDBF, iRecord, iField, 'C' ) );
1086
/************************************************************************/
1087
/* DBFReadLogicalAttribute() */
1089
/* Read a logical attribute. */
1090
/************************************************************************/
1092
const char SHPAPI_CALL1(*)
1093
DBFReadLogicalAttribute( DBFHandle psDBF, int iRecord, int iField )
1096
return( (const char *) DBFReadAttribute( psDBF, iRecord, iField, 'L' ) );
1100
/************************************************************************/
1101
/* DBFIsValueNULL() */
1103
/* Return TRUE if the passed string is NULL. */
1104
/************************************************************************/
1106
static int DBFIsValueNULL( char chType, const char* pszValue )
1110
if( pszValue == NULL )
1118
** We accept all asterisks or all blanks as NULL
1119
** though according to the spec I think it should be all
1122
if( pszValue[0] == '*' )
1125
for( i = 0; pszValue[i] != '\0'; i++ )
1127
if( pszValue[i] != ' ' )
1133
/* NULL date fields have value "00000000" */
1134
return strncmp(pszValue,"00000000",8) == 0;
1137
/* NULL boolean fields have value "?" */
1138
return pszValue[0] == '?';
1141
/* empty string fields are considered NULL */
1142
return strlen(pszValue) == 0;
1146
/************************************************************************/
1147
/* DBFIsAttributeNULL() */
1149
/* Return TRUE if value for field is NULL. */
1151
/* Contributed by Jim Matthews. */
1152
/************************************************************************/
1155
DBFIsAttributeNULL( DBFHandle psDBF, int iRecord, int iField )
1158
const char *pszValue;
1160
pszValue = DBFReadStringAttribute( psDBF, iRecord, iField );
1162
if( pszValue == NULL )
1165
return DBFIsValueNULL( psDBF->pachFieldType[iField], pszValue );
1168
/************************************************************************/
1169
/* DBFGetFieldCount() */
1171
/* Return the number of fields in this table. */
1172
/************************************************************************/
1175
DBFGetFieldCount( DBFHandle psDBF )
1178
return( psDBF->nFields );
1181
/************************************************************************/
1182
/* DBFGetRecordCount() */
1184
/* Return the number of records in this table. */
1185
/************************************************************************/
1188
DBFGetRecordCount( DBFHandle psDBF )
1191
return( psDBF->nRecords );
1194
/************************************************************************/
1195
/* DBFGetFieldInfo() */
1197
/* Return any requested information about the field. */
1198
/************************************************************************/
1200
DBFFieldType SHPAPI_CALL
1201
DBFGetFieldInfo( DBFHandle psDBF, int iField, char * pszFieldName,
1202
int * pnWidth, int * pnDecimals )
1205
if( iField < 0 || iField >= psDBF->nFields )
1206
return( FTInvalid );
1208
if( pnWidth != NULL )
1209
*pnWidth = psDBF->panFieldSize[iField];
1211
if( pnDecimals != NULL )
1212
*pnDecimals = psDBF->panFieldDecimals[iField];
1214
if( pszFieldName != NULL )
1218
strncpy( pszFieldName, (char *) psDBF->pszHeader+iField*32, 11 );
1219
pszFieldName[11] = '\0';
1220
for( i = 10; i > 0 && pszFieldName[i] == ' '; i-- )
1221
pszFieldName[i] = '\0';
1224
if ( psDBF->pachFieldType[iField] == 'L' )
1227
else if( psDBF->pachFieldType[iField] == 'N'
1228
|| psDBF->pachFieldType[iField] == 'F' )
1230
if( psDBF->panFieldDecimals[iField] > 0
1231
|| psDBF->panFieldSize[iField] > 10 )
1234
return( FTInteger );
1242
/************************************************************************/
1243
/* DBFWriteAttribute() */
1245
/* Write an attribute record to the file. */
1246
/************************************************************************/
1248
static int DBFWriteAttribute(DBFHandle psDBF, int hEntity, int iField,
1252
int i, j, nRetResult = TRUE;
1253
unsigned char *pabyRec;
1254
char szSField[400], szFormat[20];
1256
/* -------------------------------------------------------------------- */
1257
/* Is this a valid record? */
1258
/* -------------------------------------------------------------------- */
1259
if( hEntity < 0 || hEntity > psDBF->nRecords )
1262
if( psDBF->bNoHeader )
1263
DBFWriteHeader(psDBF);
1265
/* -------------------------------------------------------------------- */
1266
/* Is this a brand new record? */
1267
/* -------------------------------------------------------------------- */
1268
if( hEntity == psDBF->nRecords )
1270
if( !DBFFlushRecord( psDBF ) )
1274
for( i = 0; i < psDBF->nRecordLength; i++ )
1275
psDBF->pszCurrentRecord[i] = ' ';
1277
psDBF->nCurrentRecord = hEntity;
1280
/* -------------------------------------------------------------------- */
1281
/* Is this an existing record, but different than the last one */
1283
/* -------------------------------------------------------------------- */
1284
if( !DBFLoadRecord( psDBF, hEntity ) )
1287
pabyRec = (unsigned char *) psDBF->pszCurrentRecord;
1289
psDBF->bCurrentRecordModified = TRUE;
1290
psDBF->bUpdated = TRUE;
1292
/* -------------------------------------------------------------------- */
1293
/* Translate NULL value to valid DBF file representation. */
1295
/* Contributed by Jim Matthews. */
1296
/* -------------------------------------------------------------------- */
1297
if( pValue == NULL )
1299
memset( (char *) (pabyRec+psDBF->panFieldOffset[iField]),
1300
DBFGetNullCharacter(psDBF->pachFieldType[iField]),
1301
psDBF->panFieldSize[iField] );
1305
/* -------------------------------------------------------------------- */
1306
/* Assign all the record fields. */
1307
/* -------------------------------------------------------------------- */
1308
switch( psDBF->pachFieldType[iField] )
1313
if( psDBF->panFieldDecimals[iField] == 0 )
1315
int nWidth = psDBF->panFieldSize[iField];
1317
if( (int) sizeof(szSField)-2 < nWidth )
1318
nWidth = sizeof(szSField)-2;
1320
sprintf( szFormat, "%%%dd", nWidth );
1321
sprintf(szSField, szFormat, (int) *((double *) pValue) );
1322
if( (int)strlen(szSField) > psDBF->panFieldSize[iField] )
1324
szSField[psDBF->panFieldSize[iField]] = '\0';
1328
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
1329
szSField, strlen(szSField) );
1333
int nWidth = psDBF->panFieldSize[iField];
1335
if( (int) sizeof(szSField)-2 < nWidth )
1336
nWidth = sizeof(szSField)-2;
1338
sprintf( szFormat, "%%%d.%df",
1339
nWidth, psDBF->panFieldDecimals[iField] );
1340
sprintf(szSField, szFormat, *((double *) pValue) );
1341
if( (int) strlen(szSField) > psDBF->panFieldSize[iField] )
1343
szSField[psDBF->panFieldSize[iField]] = '\0';
1346
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
1347
szSField, strlen(szSField) );
1352
if (psDBF->panFieldSize[iField] >= 1 &&
1353
(*(char*)pValue == 'F' || *(char*)pValue == 'T'))
1354
*(pabyRec+psDBF->panFieldOffset[iField]) = *(char*)pValue;
1358
if( (int) strlen((char *) pValue) > psDBF->panFieldSize[iField] )
1360
j = psDBF->panFieldSize[iField];
1365
memset( pabyRec+psDBF->panFieldOffset[iField], ' ',
1366
psDBF->panFieldSize[iField] );
1367
j = strlen((char *) pValue);
1370
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
1371
(char *) pValue, j );
1375
return( nRetResult );
1378
/************************************************************************/
1379
/* DBFWriteAttributeDirectly() */
1381
/* Write an attribute record to the file, but without any */
1382
/* reformatting based on type. The provided buffer is written */
1383
/* as is to the field position in the record. */
1384
/************************************************************************/
1387
DBFWriteAttributeDirectly(DBFHandle psDBF, int hEntity, int iField,
1392
unsigned char *pabyRec;
1394
/* -------------------------------------------------------------------- */
1395
/* Is this a valid record? */
1396
/* -------------------------------------------------------------------- */
1397
if( hEntity < 0 || hEntity > psDBF->nRecords )
1400
if( psDBF->bNoHeader )
1401
DBFWriteHeader(psDBF);
1403
/* -------------------------------------------------------------------- */
1404
/* Is this a brand new record? */
1405
/* -------------------------------------------------------------------- */
1406
if( hEntity == psDBF->nRecords )
1408
if( !DBFFlushRecord( psDBF ) )
1412
for( i = 0; i < psDBF->nRecordLength; i++ )
1413
psDBF->pszCurrentRecord[i] = ' ';
1415
psDBF->nCurrentRecord = hEntity;
1418
/* -------------------------------------------------------------------- */
1419
/* Is this an existing record, but different than the last one */
1421
/* -------------------------------------------------------------------- */
1422
if( !DBFLoadRecord( psDBF, hEntity ) )
1425
pabyRec = (unsigned char *) psDBF->pszCurrentRecord;
1427
/* -------------------------------------------------------------------- */
1428
/* Assign all the record fields. */
1429
/* -------------------------------------------------------------------- */
1430
if( (int)strlen((char *) pValue) > psDBF->panFieldSize[iField] )
1431
j = psDBF->panFieldSize[iField];
1434
memset( pabyRec+psDBF->panFieldOffset[iField], ' ',
1435
psDBF->panFieldSize[iField] );
1436
j = strlen((char *) pValue);
1439
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
1440
(char *) pValue, j );
1442
psDBF->bCurrentRecordModified = TRUE;
1443
psDBF->bUpdated = TRUE;
1448
/************************************************************************/
1449
/* DBFWriteDoubleAttribute() */
1451
/* Write a double attribute. */
1452
/************************************************************************/
1455
DBFWriteDoubleAttribute( DBFHandle psDBF, int iRecord, int iField,
1459
return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) &dValue ) );
1462
/************************************************************************/
1463
/* DBFWriteIntegerAttribute() */
1465
/* Write a integer attribute. */
1466
/************************************************************************/
1469
DBFWriteIntegerAttribute( DBFHandle psDBF, int iRecord, int iField,
1473
double dValue = nValue;
1475
return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) &dValue ) );
1478
/************************************************************************/
1479
/* DBFWriteStringAttribute() */
1481
/* Write a string attribute. */
1482
/************************************************************************/
1485
DBFWriteStringAttribute( DBFHandle psDBF, int iRecord, int iField,
1486
const char * pszValue )
1489
return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) pszValue ) );
1492
/************************************************************************/
1493
/* DBFWriteNULLAttribute() */
1495
/* Write a string attribute. */
1496
/************************************************************************/
1499
DBFWriteNULLAttribute( DBFHandle psDBF, int iRecord, int iField )
1502
return( DBFWriteAttribute( psDBF, iRecord, iField, NULL ) );
1505
/************************************************************************/
1506
/* DBFWriteLogicalAttribute() */
1508
/* Write a logical attribute. */
1509
/************************************************************************/
1512
DBFWriteLogicalAttribute( DBFHandle psDBF, int iRecord, int iField,
1516
return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) (&lValue) ) );
1519
/************************************************************************/
1520
/* DBFWriteTuple() */
1522
/* Write an attribute record to the file. */
1523
/************************************************************************/
1526
DBFWriteTuple(DBFHandle psDBF, int hEntity, void * pRawTuple )
1530
unsigned char *pabyRec;
1532
/* -------------------------------------------------------------------- */
1533
/* Is this a valid record? */
1534
/* -------------------------------------------------------------------- */
1535
if( hEntity < 0 || hEntity > psDBF->nRecords )
1538
if( psDBF->bNoHeader )
1539
DBFWriteHeader(psDBF);
1541
/* -------------------------------------------------------------------- */
1542
/* Is this a brand new record? */
1543
/* -------------------------------------------------------------------- */
1544
if( hEntity == psDBF->nRecords )
1546
if( !DBFFlushRecord( psDBF ) )
1550
for( i = 0; i < psDBF->nRecordLength; i++ )
1551
psDBF->pszCurrentRecord[i] = ' ';
1553
psDBF->nCurrentRecord = hEntity;
1556
/* -------------------------------------------------------------------- */
1557
/* Is this an existing record, but different than the last one */
1559
/* -------------------------------------------------------------------- */
1560
if( !DBFLoadRecord( psDBF, hEntity ) )
1563
pabyRec = (unsigned char *) psDBF->pszCurrentRecord;
1565
memcpy ( pabyRec, pRawTuple, psDBF->nRecordLength );
1567
psDBF->bCurrentRecordModified = TRUE;
1568
psDBF->bUpdated = TRUE;
1573
/************************************************************************/
1574
/* DBFReadTuple() */
1576
/* Read a complete record. Note that the result is only valid */
1577
/* till the next record read for any reason. */
1578
/************************************************************************/
1580
const char SHPAPI_CALL1(*)
1581
DBFReadTuple(DBFHandle psDBF, int hEntity )
1584
if( hEntity < 0 || hEntity >= psDBF->nRecords )
1587
if( !DBFLoadRecord( psDBF, hEntity ) )
1590
return (const char *) psDBF->pszCurrentRecord;
1593
/************************************************************************/
1594
/* DBFCloneEmpty() */
1596
/* Read one of the attribute fields of a record. */
1597
/************************************************************************/
1599
DBFHandle SHPAPI_CALL
1600
DBFCloneEmpty(DBFHandle psDBF, const char * pszFilename )
1604
newDBF = DBFCreateEx ( pszFilename, psDBF->pszCodePage );
1605
if ( newDBF == NULL ) return ( NULL );
1607
newDBF->nFields = psDBF->nFields;
1608
newDBF->nRecordLength = psDBF->nRecordLength;
1609
newDBF->nHeaderLength = psDBF->nHeaderLength;
1611
newDBF->pszHeader = (char *) malloc ( newDBF->nHeaderLength );
1612
memcpy ( newDBF->pszHeader, psDBF->pszHeader, newDBF->nHeaderLength );
1614
newDBF->panFieldOffset = (int *) malloc ( sizeof(int) * psDBF->nFields );
1615
memcpy ( newDBF->panFieldOffset, psDBF->panFieldOffset, sizeof(int) * psDBF->nFields );
1616
newDBF->panFieldSize = (int *) malloc ( sizeof(int) * psDBF->nFields );
1617
memcpy ( newDBF->panFieldSize, psDBF->panFieldSize, sizeof(int) * psDBF->nFields );
1618
newDBF->panFieldDecimals = (int *) malloc ( sizeof(int) * psDBF->nFields );
1619
memcpy ( newDBF->panFieldDecimals, psDBF->panFieldDecimals, sizeof(int) * psDBF->nFields );
1620
newDBF->pachFieldType = (char *) malloc ( sizeof(char) * psDBF->nFields );
1621
memcpy ( newDBF->pachFieldType, psDBF->pachFieldType, sizeof(char)*psDBF->nFields );
1623
newDBF->bNoHeader = TRUE;
1624
newDBF->bUpdated = TRUE;
1626
DBFWriteHeader ( newDBF );
1627
DBFClose ( newDBF );
1629
newDBF = DBFOpen ( pszFilename, "rb+" );
1634
/************************************************************************/
1635
/* DBFGetNativeFieldType() */
1637
/* Return the DBase field type for the specified field. */
1639
/* Value can be one of: 'C' (String), 'D' (Date), 'F' (Float), */
1640
/* 'N' (Numeric, with or without decimal), */
1641
/* 'L' (Logical), */
1642
/* 'M' (Memo: 10 digits .DBT block ptr) */
1643
/************************************************************************/
1646
DBFGetNativeFieldType( DBFHandle psDBF, int iField )
1649
if( iField >=0 && iField < psDBF->nFields )
1650
return psDBF->pachFieldType[iField];
1655
/************************************************************************/
1656
/* str_to_upper() */
1657
/************************************************************************/
1659
static void str_to_upper (char *string)
1664
len = strlen (string);
1667
if (isalpha(string[i]) && islower(string[i]))
1668
string[i] = (char) toupper ((int)string[i]);
1671
/************************************************************************/
1672
/* DBFGetFieldIndex() */
1674
/* Get the index number for a field in a .dbf file. */
1676
/* Contributed by Jim Matthews. */
1677
/************************************************************************/
1680
DBFGetFieldIndex(DBFHandle psDBF, const char *pszFieldName)
1683
char name[12], name1[12], name2[12];
1686
strncpy(name1, pszFieldName,11);
1688
str_to_upper(name1);
1690
for( i = 0; i < DBFGetFieldCount(psDBF); i++ )
1692
DBFGetFieldInfo( psDBF, i, name, NULL, NULL );
1693
strncpy(name2,name,11);
1694
str_to_upper(name2);
1696
if(!strncmp(name1,name2,10))
1702
/************************************************************************/
1703
/* DBFIsRecordDeleted() */
1705
/* Returns TRUE if the indicated record is deleted, otherwise */
1706
/* it returns FALSE. */
1707
/************************************************************************/
1709
int SHPAPI_CALL DBFIsRecordDeleted( DBFHandle psDBF, int iShape )
1712
/* -------------------------------------------------------------------- */
1713
/* Verify selection. */
1714
/* -------------------------------------------------------------------- */
1715
if( iShape < 0 || iShape >= psDBF->nRecords )
1718
/* -------------------------------------------------------------------- */
1719
/* Have we read the record? */
1720
/* -------------------------------------------------------------------- */
1721
if( !DBFLoadRecord( psDBF, iShape ) )
1724
/* -------------------------------------------------------------------- */
1725
/* '*' means deleted. */
1726
/* -------------------------------------------------------------------- */
1727
return psDBF->pszCurrentRecord[0] == '*';
1730
/************************************************************************/
1731
/* DBFMarkRecordDeleted() */
1732
/************************************************************************/
1734
int SHPAPI_CALL DBFMarkRecordDeleted( DBFHandle psDBF, int iShape,
1740
/* -------------------------------------------------------------------- */
1741
/* Verify selection. */
1742
/* -------------------------------------------------------------------- */
1743
if( iShape < 0 || iShape >= psDBF->nRecords )
1746
/* -------------------------------------------------------------------- */
1747
/* Is this an existing record, but different than the last one */
1749
/* -------------------------------------------------------------------- */
1750
if( !DBFLoadRecord( psDBF, iShape ) )
1753
/* -------------------------------------------------------------------- */
1754
/* Assign value, marking record as dirty if it changes. */
1755
/* -------------------------------------------------------------------- */
1761
if( psDBF->pszCurrentRecord[0] != chNewFlag )
1763
psDBF->bCurrentRecordModified = TRUE;
1764
psDBF->bUpdated = TRUE;
1765
psDBF->pszCurrentRecord[0] = chNewFlag;
1771
/************************************************************************/
1772
/* DBFGetCodePage */
1773
/************************************************************************/
1775
const char SHPAPI_CALL1(*)
1776
DBFGetCodePage(DBFHandle psDBF )
1780
return psDBF->pszCodePage;
1783
/************************************************************************/
1784
/* DBFDeleteField() */
1786
/* Remove a field from a .dbf file */
1787
/************************************************************************/
1790
DBFDeleteField(DBFHandle psDBF, int iField)
1792
int nOldRecordLength, nOldHeaderLength;
1793
int nDeletedFieldOffset, nDeletedFieldSize;
1794
SAOffset nRecordOffset;
1798
if (iField < 0 || iField >= psDBF->nFields)
1801
/* make sure that everything is written in .dbf */
1802
if( !DBFFlushRecord( psDBF ) )
1805
/* get information about field to be deleted */
1806
nOldRecordLength = psDBF->nRecordLength;
1807
nOldHeaderLength = psDBF->nHeaderLength;
1808
nDeletedFieldOffset = psDBF->panFieldOffset[iField];
1809
nDeletedFieldSize = psDBF->panFieldSize[iField];
1811
/* update fields info */
1812
for (i = iField + 1; i < psDBF->nFields; i++)
1814
psDBF->panFieldOffset[i-1] = psDBF->panFieldOffset[i] - nDeletedFieldSize;
1815
psDBF->panFieldSize[i-1] = psDBF->panFieldSize[i];
1816
psDBF->panFieldDecimals[i-1] = psDBF->panFieldDecimals[i];
1817
psDBF->pachFieldType[i-1] = psDBF->pachFieldType[i];
1820
/* resize fields arrays */
1823
psDBF->panFieldOffset = (int *)
1824
SfRealloc( psDBF->panFieldOffset, sizeof(int) * psDBF->nFields );
1826
psDBF->panFieldSize = (int *)
1827
SfRealloc( psDBF->panFieldSize, sizeof(int) * psDBF->nFields );
1829
psDBF->panFieldDecimals = (int *)
1830
SfRealloc( psDBF->panFieldDecimals, sizeof(int) * psDBF->nFields );
1832
psDBF->pachFieldType = (char *)
1833
SfRealloc( psDBF->pachFieldType, sizeof(char) * psDBF->nFields );
1835
/* update header information */
1836
psDBF->nHeaderLength -= 32;
1837
psDBF->nRecordLength -= nDeletedFieldSize;
1839
/* overwrite field information in header */
1840
memmove(psDBF->pszHeader + iField*32,
1841
psDBF->pszHeader + (iField+1)*32,
1842
sizeof(char) * (psDBF->nFields - iField)*32);
1844
psDBF->pszHeader = (char *) SfRealloc(psDBF->pszHeader,psDBF->nFields*32);
1846
/* update size of current record appropriately */
1847
psDBF->pszCurrentRecord = (char *) SfRealloc(psDBF->pszCurrentRecord,
1848
psDBF->nRecordLength);
1850
/* we're done if we're dealing with not yet created .dbf */
1851
if ( psDBF->bNoHeader && psDBF->nRecords == 0 )
1854
/* force update of header with new header and record length */
1855
psDBF->bNoHeader = TRUE;
1856
DBFUpdateHeader( psDBF );
1859
pszRecord = (char *) malloc(sizeof(char) * nOldRecordLength);
1861
/* shift records to their new positions */
1862
for (iRecord = 0; iRecord < psDBF->nRecords; iRecord++)
1865
nOldRecordLength * (SAOffset) iRecord + nOldHeaderLength;
1868
psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 );
1869
psDBF->sHooks.FRead( pszRecord, nOldRecordLength, 1, psDBF->fp );
1872
psDBF->nRecordLength * (SAOffset) iRecord + psDBF->nHeaderLength;
1874
/* move record in two steps */
1875
psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 );
1876
psDBF->sHooks.FWrite( pszRecord, nDeletedFieldOffset, 1, psDBF->fp );
1877
psDBF->sHooks.FWrite( pszRecord + nDeletedFieldOffset + nDeletedFieldSize,
1878
nOldRecordLength - nDeletedFieldOffset - nDeletedFieldSize,
1883
/* TODO: truncate file */
1888
psDBF->nCurrentRecord = -1;
1889
psDBF->bCurrentRecordModified = FALSE;
1894
/************************************************************************/
1895
/* DBFReorderFields() */
1897
/* Reorder the fields of a .dbf file */
1899
/* panMap must be exactly psDBF->nFields long and be a permutation */
1900
/* of [0, psDBF->nFields-1]. This assumption will not be asserted in the*/
1901
/* code of DBFReorderFields. */
1902
/************************************************************************/
1905
DBFReorderFields( DBFHandle psDBF, int* panMap )
1907
SAOffset nRecordOffset;
1909
int *panFieldOffsetNew;
1910
int *panFieldSizeNew;
1911
int *panFieldDecimalsNew;
1912
char *pachFieldTypeNew;
1917
if ( psDBF->nFields == 0 )
1920
/* make sure that everything is written in .dbf */
1921
if( !DBFFlushRecord( psDBF ) )
1924
panFieldOffsetNew = (int *) malloc(sizeof(int) * psDBF->nFields);
1925
panFieldSizeNew = (int *) malloc(sizeof(int) * psDBF->nFields);
1926
panFieldDecimalsNew = (int *) malloc(sizeof(int) * psDBF->nFields);
1927
pachFieldTypeNew = (char *) malloc(sizeof(char) * psDBF->nFields);
1928
pszHeaderNew = (char*) malloc(sizeof(char) * 32 * psDBF->nFields);
1930
/* shuffle fields definitions */
1931
for(i=0; i < psDBF->nFields; i++)
1933
panFieldSizeNew[i] = psDBF->panFieldSize[panMap[i]];
1934
panFieldDecimalsNew[i] = psDBF->panFieldDecimals[panMap[i]];
1935
pachFieldTypeNew[i] = psDBF->pachFieldType[panMap[i]];
1936
memcpy(pszHeaderNew + i * 32,
1937
psDBF->pszHeader + panMap[i] * 32, 32);
1939
panFieldOffsetNew[0] = 1;
1940
for(i=1; i < psDBF->nFields; i++)
1942
panFieldOffsetNew[i] = panFieldOffsetNew[i - 1] + panFieldSizeNew[i - 1];
1945
free(psDBF->pszHeader);
1946
psDBF->pszHeader = pszHeaderNew;
1948
/* we're done if we're dealing with not yet created .dbf */
1949
if ( !(psDBF->bNoHeader && psDBF->nRecords == 0) )
1951
/* force update of header with new header and record length */
1952
psDBF->bNoHeader = TRUE;
1953
DBFUpdateHeader( psDBF );
1956
pszRecord = (char *) malloc(sizeof(char) * psDBF->nRecordLength);
1957
pszRecordNew = (char *) malloc(sizeof(char) * psDBF->nRecordLength);
1959
/* shuffle fields in records */
1960
for (iRecord = 0; iRecord < psDBF->nRecords; iRecord++)
1963
psDBF->nRecordLength * (SAOffset) iRecord + psDBF->nHeaderLength;
1966
psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 );
1967
psDBF->sHooks.FRead( pszRecord, psDBF->nRecordLength, 1, psDBF->fp );
1969
pszRecordNew[0] = pszRecord[0];
1971
for(i=0; i < psDBF->nFields; i++)
1973
memcpy(pszRecordNew + panFieldOffsetNew[i],
1974
pszRecord + psDBF->panFieldOffset[panMap[i]],
1975
psDBF->panFieldSize[panMap[i]]);
1979
psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 );
1980
psDBF->sHooks.FWrite( pszRecordNew, psDBF->nRecordLength, 1, psDBF->fp );
1988
free(psDBF->panFieldOffset);
1989
free(psDBF->panFieldSize);
1990
free(psDBF->panFieldDecimals);
1991
free(psDBF->pachFieldType);
1993
psDBF->panFieldOffset = panFieldOffsetNew;
1994
psDBF->panFieldSize = panFieldSizeNew;
1995
psDBF->panFieldDecimals =panFieldDecimalsNew;
1996
psDBF->pachFieldType = pachFieldTypeNew;
1998
psDBF->nCurrentRecord = -1;
1999
psDBF->bCurrentRecordModified = FALSE;
2005
/************************************************************************/
2006
/* DBFAlterFieldDefn() */
2008
/* Alter a field definition in a .dbf file */
2009
/************************************************************************/
2012
DBFAlterFieldDefn( DBFHandle psDBF, int iField, const char * pszFieldName,
2013
char chType, int nWidth, int nDecimals )
2019
int nOldRecordLength;
2026
if (iField < 0 || iField >= psDBF->nFields)
2029
/* make sure that everything is written in .dbf */
2030
if( !DBFFlushRecord( psDBF ) )
2033
chFieldFill = DBFGetNullCharacter(chType);
2035
chOldType = psDBF->pachFieldType[iField];
2036
nOffset = psDBF->panFieldOffset[iField];
2037
nOldWidth = psDBF->panFieldSize[iField];
2038
nOldRecordLength = psDBF->nRecordLength;
2040
/* -------------------------------------------------------------------- */
2041
/* Do some checking to ensure we can add records to this file. */
2042
/* -------------------------------------------------------------------- */
2049
/* -------------------------------------------------------------------- */
2050
/* Assign the new field information fields. */
2051
/* -------------------------------------------------------------------- */
2052
psDBF->panFieldSize[iField] = nWidth;
2053
psDBF->panFieldDecimals[iField] = nDecimals;
2054
psDBF->pachFieldType[iField] = chType;
2056
/* -------------------------------------------------------------------- */
2057
/* Update the header information. */
2058
/* -------------------------------------------------------------------- */
2059
pszFInfo = psDBF->pszHeader + 32 * iField;
2061
for( i = 0; i < 32; i++ )
2064
if( (int) strlen(pszFieldName) < 10 )
2065
strncpy( pszFInfo, pszFieldName, strlen(pszFieldName));
2067
strncpy( pszFInfo, pszFieldName, 10);
2069
pszFInfo[11] = psDBF->pachFieldType[iField];
2073
pszFInfo[16] = (unsigned char) (nWidth % 256);
2074
pszFInfo[17] = (unsigned char) (nWidth / 256);
2078
pszFInfo[16] = (unsigned char) nWidth;
2079
pszFInfo[17] = (unsigned char) nDecimals;
2082
/* -------------------------------------------------------------------- */
2083
/* Update offsets */
2084
/* -------------------------------------------------------------------- */
2085
if (nWidth != nOldWidth)
2087
for (i = iField + 1; i < psDBF->nFields; i++)
2088
psDBF->panFieldOffset[i] += nWidth - nOldWidth;
2089
psDBF->nRecordLength += nWidth - nOldWidth;
2091
psDBF->pszCurrentRecord = (char *) SfRealloc(psDBF->pszCurrentRecord,
2092
psDBF->nRecordLength);
2095
/* we're done if we're dealing with not yet created .dbf */
2096
if ( psDBF->bNoHeader && psDBF->nRecords == 0 )
2099
/* force update of header with new header and record length */
2100
psDBF->bNoHeader = TRUE;
2101
DBFUpdateHeader( psDBF );
2103
if (nWidth < nOldWidth || (nWidth == nOldWidth && chType != chOldType))
2105
char* pszRecord = (char *) malloc(sizeof(char) * nOldRecordLength);
2106
char* pszOldField = (char *) malloc(sizeof(char) * (nOldWidth + 1));
2108
pszOldField[nOldWidth] = 0;
2110
/* move records to their new positions */
2111
for (iRecord = 0; iRecord < psDBF->nRecords; iRecord++)
2114
nOldRecordLength * (SAOffset) iRecord + psDBF->nHeaderLength;
2117
psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 );
2118
psDBF->sHooks.FRead( pszRecord, nOldRecordLength, 1, psDBF->fp );
2120
memcpy(pszOldField, pszRecord + nOffset, nOldWidth);
2121
bIsNULL = DBFIsValueNULL( chOldType, pszOldField );
2123
if (nWidth != nOldWidth)
2125
if ((chOldType == 'N' || chOldType == 'F') && pszOldField[0] == ' ')
2127
/* Strip leading spaces when truncating a numeric field */
2128
memmove( pszRecord + nOffset,
2129
pszRecord + nOffset + nOldWidth - nWidth,
2132
if (nOffset + nOldWidth < nOldRecordLength)
2134
memmove( pszRecord + nOffset + nWidth,
2135
pszRecord + nOffset + nOldWidth,
2136
nOldRecordLength - (nOffset + nOldWidth));
2140
/* Convert null value to the appropriate value of the new type */
2143
memset( pszRecord + nOffset, chFieldFill, nWidth);
2147
psDBF->nRecordLength * (SAOffset) iRecord + psDBF->nHeaderLength;
2150
psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 );
2151
psDBF->sHooks.FWrite( pszRecord, psDBF->nRecordLength, 1, psDBF->fp );
2157
else if (nWidth > nOldWidth)
2159
char* pszRecord = (char *) malloc(sizeof(char) * psDBF->nRecordLength);
2160
char* pszOldField = (char *) malloc(sizeof(char) * (nOldWidth + 1));
2162
pszOldField[nOldWidth] = 0;
2164
/* move records to their new positions */
2165
for (iRecord = psDBF->nRecords - 1; iRecord >= 0; iRecord--)
2168
nOldRecordLength * (SAOffset) iRecord + psDBF->nHeaderLength;
2171
psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 );
2172
psDBF->sHooks.FRead( pszRecord, nOldRecordLength, 1, psDBF->fp );
2174
memcpy(pszOldField, pszRecord + nOffset, nOldWidth);
2175
bIsNULL = DBFIsValueNULL( chOldType, pszOldField );
2177
if (nOffset + nOldWidth < nOldRecordLength)
2179
memmove( pszRecord + nOffset + nWidth,
2180
pszRecord + nOffset + nOldWidth,
2181
nOldRecordLength - (nOffset + nOldWidth));
2184
/* Convert null value to the appropriate value of the new type */
2187
memset( pszRecord + nOffset, chFieldFill, nWidth);
2191
if ((chOldType == 'N' || chOldType == 'F'))
2193
/* Add leading spaces when expanding a numeric field */
2194
memmove( pszRecord + nOffset + nWidth - nOldWidth,
2195
pszRecord + nOffset, nOldWidth );
2196
memset( pszRecord + nOffset, ' ', nWidth - nOldWidth );
2200
/* Add trailing spaces */
2201
memset(pszRecord + nOffset + nOldWidth, ' ', nWidth - nOldWidth);
2206
psDBF->nRecordLength * (SAOffset) iRecord + psDBF->nHeaderLength;
2209
psDBF->sHooks.FSeek( psDBF->fp, nRecordOffset, 0 );
2210
psDBF->sHooks.FWrite( pszRecord, psDBF->nRecordLength, 1, psDBF->fp );
2217
psDBF->nCurrentRecord = -1;
2218
psDBF->bCurrentRecordModified = FALSE;
added
removed
plugins/importshp/shapelib/dbfopen.c
