1
/******************************************************************************
2
* $Id: dbfopen.c 1581 2004-06-14 04:35:20Z gsherman $
5
* Purpose: Implementation of .dbf access API documented in dbf_api.html.
6
* Author: Frank Warmerdam, warmerda@home.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.2 2004/06/14 04:35:19 gsherman
38
* Changes to support Windows version
40
* Revision 1.1 2004/04/05 15:39:45 timlinux
41
* Initial commit of new plugin to build graticules - not working yet! And thus not added to higher level makefiles yet.
43
* Revision 1.2 2004/03/31 20:36:46 timlinux
44
* Fix for knock on effects of change of filename from shapefil.h to shapefile.h
46
* Revision 1.1 2004/03/22 23:38:25 timlinux
47
* This is a c++ first draft of a port of a perl script by Schuyler to import Garmin gps dump files as a shapefile. The resulting imported file will be displayed in the map view. At the moment it only generates a point layer of the waypoints but a future version will generate polylines and perhaps polygons too using similar logic to that used by Shuylers perl stuff. Note this plugin is still under construction and I am commiting it mainly so that other developers can assist me when I get stuck. Also note that the plugins Makefile builds a standalone app based on the plugin gui that can be run separately from qgis.
49
* Revision 1.22 1999/12/15 13:47:24 warmerda
50
* Added stdlib.h to ensure that atof() is prototyped.
52
* Revision 1.21 1999/12/13 17:25:46 warmerda
53
* Added support for upper case .DBF extention.
55
* Revision 1.20 1999/11/30 16:32:11 warmerda
56
* Use atof() instead of sscanf().
58
* Revision 1.19 1999/11/05 14:12:04 warmerda
59
* updated license terms
61
* Revision 1.18 1999/07/27 00:53:28 warmerda
62
* ensure that whole old field value clear on write of string
64
* Revision 1.1 1999/07/05 18:58:07 warmerda
67
* Revision 1.17 1999/06/11 19:14:12 warmerda
68
* Fixed some memory leaks.
70
* Revision 1.16 1999/06/11 19:04:11 warmerda
71
* Remoted some unused variables.
73
* Revision 1.15 1999/05/11 03:19:28 warmerda
74
* added new Tuple api, and improved extension handling - add from candrsn
76
* Revision 1.14 1999/05/04 15:01:48 warmerda
79
* Revision 1.13 1999/03/23 17:38:59 warmerda
80
* DBFAddField() now actually does return the new field number, or -1 if
83
* Revision 1.12 1999/03/06 02:54:46 warmerda
84
* Added logic to convert shapefile name to dbf filename in DBFOpen()
87
* Revision 1.11 1998/12/31 15:30:34 warmerda
88
* Improved the interchangability of numeric and string attributes. Add
89
* white space trimming option for attributes.
91
* Revision 1.10 1998/12/03 16:36:44 warmerda
92
* Use r+b instead of rb+ for binary access.
94
* Revision 1.9 1998/12/03 15:34:23 warmerda
95
* Updated copyright message.
97
* Revision 1.8 1997/12/04 15:40:15 warmerda
98
* Added newline character after field definitions.
100
* Revision 1.7 1997/03/06 14:02:10 warmerda
101
* Ensure bUpdated is initialized.
103
* Revision 1.6 1996/02/12 04:54:41 warmerda
104
* Ensure that DBFWriteAttribute() returns TRUE if it succeeds.
106
* Revision 1.5 1995/10/21 03:15:12 warmerda
107
* Changed to use binary file access, and ensure that the
108
* field name field is zero filled, and limited to 10 chars.
110
* Revision 1.4 1995/08/24 18:10:42 warmerda
111
* Added use of SfRealloc() to avoid pre-ANSI realloc() functions such
114
* Revision 1.3 1995/08/04 03:15:16 warmerda
117
* Revision 1.2 1995/08/04 03:14:43 warmerda
121
static char rcsid[] =
122
"$Id: dbfopen.c 1581 2004-06-14 04:35:20Z gsherman $";
124
#include "shapefile.h"
131
typedef unsigned char uchar;
138
static int nStringFieldLen = 0;
139
static char * pszStringField = NULL;
141
/************************************************************************/
144
/* A realloc cover function that will access a NULL pointer as */
146
/************************************************************************/
148
static void * SfRealloc( void * pMem, int nNewSize )
152
return( (void *) malloc(nNewSize) );
154
return( (void *) realloc(pMem,nNewSize) );
157
/************************************************************************/
158
/* DBFWriteHeader() */
160
/* This is called to write out the file header, and field */
161
/* descriptions before writing any actual data records. This */
162
/* also computes all the DBFDataSet field offset/size/decimals */
163
/* and so forth values. */
164
/************************************************************************/
166
static void DBFWriteHeader(DBFHandle psDBF)
169
uchar abyHeader[XBASE_FLDHDR_SZ];
172
if( !psDBF->bNoHeader )
175
psDBF->bNoHeader = FALSE;
177
/* -------------------------------------------------------------------- */
178
/* Initialize the file header information. */
179
/* -------------------------------------------------------------------- */
180
for( i = 0; i < XBASE_FLDHDR_SZ; i++ )
183
abyHeader[0] = 0x03; /* memo field? - just copying */
185
/* date updated on close, record count preset at zero */
187
abyHeader[8] = psDBF->nHeaderLength % 256;
188
abyHeader[9] = psDBF->nHeaderLength / 256;
190
abyHeader[10] = psDBF->nRecordLength % 256;
191
abyHeader[11] = psDBF->nRecordLength / 256;
193
/* -------------------------------------------------------------------- */
194
/* Write the initial 32 byte file header, and all the field */
196
/* -------------------------------------------------------------------- */
197
fseek( psDBF->fp, 0, 0 );
198
fwrite( abyHeader, XBASE_FLDHDR_SZ, 1, psDBF->fp );
199
fwrite( psDBF->pszHeader, XBASE_FLDHDR_SZ, psDBF->nFields, psDBF->fp );
201
/* -------------------------------------------------------------------- */
202
/* Write out the newline character if there is room for it. */
203
/* -------------------------------------------------------------------- */
204
if( psDBF->nHeaderLength > 32*psDBF->nFields + 32 )
209
fwrite( &cNewline, 1, 1, psDBF->fp );
213
/************************************************************************/
214
/* DBFFlushRecord() */
216
/* Write out the current record if there is one. */
217
/************************************************************************/
219
static void DBFFlushRecord( DBFHandle psDBF )
224
if( psDBF->bCurrentRecordModified && psDBF->nCurrentRecord > -1 )
226
psDBF->bCurrentRecordModified = FALSE;
228
nRecordOffset = psDBF->nRecordLength * psDBF->nCurrentRecord
229
+ psDBF->nHeaderLength;
231
fseek( psDBF->fp, nRecordOffset, 0 );
232
fwrite( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );
236
/************************************************************************/
239
/* Open a .dbf file. */
240
/************************************************************************/
242
DBFHandle DBFOpen( const char * pszFilename, const char * pszAccess )
247
int nFields, nRecords, nHeadLen, nRecLen, iField, i;
248
char *pszBasename, *pszFullname;
250
/* -------------------------------------------------------------------- */
251
/* We only allow the access strings "rb" and "r+". */
252
/* -------------------------------------------------------------------- */
253
if( strcmp(pszAccess,"r") != 0 && strcmp(pszAccess,"r+") != 0
254
&& strcmp(pszAccess,"rb") != 0 && strcmp(pszAccess,"rb+") != 0
255
&& strcmp(pszAccess,"r+b") != 0 )
258
/* -------------------------------------------------------------------- */
259
/* Compute the base (layer) name. If there is any extension */
260
/* on the passed in filename we will strip it off. */
261
/* -------------------------------------------------------------------- */
262
pszBasename = (char *) malloc(strlen(pszFilename)+5);
263
strcpy( pszBasename, pszFilename );
264
for( i = strlen(pszBasename)-1;
265
i > 0 && pszBasename[i] != '.' && pszBasename[i] != '/'
266
&& pszBasename[i] != '\\';
269
if( pszBasename[i] == '.' )
270
pszBasename[i] = '\0';
272
pszFullname = (char *) malloc(strlen(pszBasename) + 5);
273
sprintf( pszFullname, "%s.dbf", pszBasename );
275
psDBF = (DBFHandle) calloc( 1, sizeof(DBFInfo) );
276
psDBF->fp = fopen( pszFullname, pszAccess );
278
if( psDBF->fp == NULL )
280
sprintf( pszFullname, "%s.DBF", pszBasename );
281
psDBF->fp = fopen(pszFullname, pszAccess );
287
if( psDBF->fp == NULL )
293
psDBF->bNoHeader = FALSE;
294
psDBF->nCurrentRecord = -1;
295
psDBF->bCurrentRecordModified = FALSE;
297
/* -------------------------------------------------------------------- */
298
/* Read Table Header info */
299
/* -------------------------------------------------------------------- */
300
pabyBuf = (uchar *) malloc(500);
301
fread( pabyBuf, 32, 1, psDBF->fp );
303
psDBF->nRecords = nRecords =
304
pabyBuf[4] + pabyBuf[5]*256 + pabyBuf[6]*256*256 + pabyBuf[7]*256*256*256;
306
psDBF->nHeaderLength = nHeadLen = pabyBuf[8] + pabyBuf[9]*256;
307
psDBF->nRecordLength = nRecLen = pabyBuf[10] + pabyBuf[11]*256;
309
psDBF->nFields = nFields = (nHeadLen - 32) / 32;
311
psDBF->pszCurrentRecord = (char *) malloc(nRecLen);
313
/* -------------------------------------------------------------------- */
314
/* Read in Field Definitions */
315
/* -------------------------------------------------------------------- */
317
pabyBuf = (uchar *) SfRealloc(pabyBuf,nHeadLen);
318
psDBF->pszHeader = (char *) pabyBuf;
320
fseek( psDBF->fp, 32, 0 );
321
fread( pabyBuf, nHeadLen, 1, psDBF->fp );
323
psDBF->panFieldOffset = (int *) malloc(sizeof(int) * nFields);
324
psDBF->panFieldSize = (int *) malloc(sizeof(int) * nFields);
325
psDBF->panFieldDecimals = (int *) malloc(sizeof(int) * nFields);
326
psDBF->pachFieldType = (char *) malloc(sizeof(char) * nFields);
328
for( iField = 0; iField < nFields; iField++ )
332
pabyFInfo = pabyBuf+iField*32;
334
if( pabyFInfo[11] == 'N' || pabyFInfo[11] == 'F' )
336
psDBF->panFieldSize[iField] = pabyFInfo[16];
337
psDBF->panFieldDecimals[iField] = pabyFInfo[17];
341
psDBF->panFieldSize[iField] = pabyFInfo[16] + pabyFInfo[17]*256;
342
psDBF->panFieldDecimals[iField] = 0;
345
psDBF->pachFieldType[iField] = (char) pabyFInfo[11];
347
psDBF->panFieldOffset[iField] = 1;
349
psDBF->panFieldOffset[iField] =
350
psDBF->panFieldOffset[iField-1] + psDBF->panFieldSize[iField-1];
356
/************************************************************************/
358
/************************************************************************/
360
void DBFClose(DBFHandle psDBF)
362
/* -------------------------------------------------------------------- */
363
/* Write out header if not already written. */
364
/* -------------------------------------------------------------------- */
365
if( psDBF->bNoHeader )
366
DBFWriteHeader( psDBF );
368
DBFFlushRecord( psDBF );
370
/* -------------------------------------------------------------------- */
371
/* Update last access date, and number of records if we have */
373
/* -------------------------------------------------------------------- */
374
if( psDBF->bUpdated )
376
uchar abyFileHeader[32];
378
fseek( psDBF->fp, 0, 0 );
379
fread( abyFileHeader, 32, 1, psDBF->fp );
381
abyFileHeader[1] = 95; /* YY */
382
abyFileHeader[2] = 7; /* MM */
383
abyFileHeader[3] = 26; /* DD */
385
abyFileHeader[4] = psDBF->nRecords % 256;
386
abyFileHeader[5] = (psDBF->nRecords/256) % 256;
387
abyFileHeader[6] = (psDBF->nRecords/(256*256)) % 256;
388
abyFileHeader[7] = (psDBF->nRecords/(256*256*256)) % 256;
390
fseek( psDBF->fp, 0, 0 );
391
fwrite( abyFileHeader, 32, 1, psDBF->fp );
394
/* -------------------------------------------------------------------- */
395
/* Close, and free resources. */
396
/* -------------------------------------------------------------------- */
399
if( psDBF->panFieldOffset != NULL )
401
free( psDBF->panFieldOffset );
402
free( psDBF->panFieldSize );
403
free( psDBF->panFieldDecimals );
404
free( psDBF->pachFieldType );
407
free( psDBF->pszHeader );
408
free( psDBF->pszCurrentRecord );
412
if( pszStringField != NULL )
414
free( pszStringField );
415
pszStringField = NULL;
420
/************************************************************************/
423
/* Create a new .dbf file. */
424
/************************************************************************/
426
DBFHandle DBFCreate( const char * pszFilename )
431
char *pszFullname, *pszBasename;
434
/* -------------------------------------------------------------------- */
435
/* Compute the base (layer) name. If there is any extension */
436
/* on the passed in filename we will strip it off. */
437
/* -------------------------------------------------------------------- */
438
pszBasename = (char *) malloc(strlen(pszFilename)+5);
439
strcpy( pszBasename, pszFilename );
440
for( i = strlen(pszBasename)-1;
441
i > 0 && pszBasename[i] != '.' && pszBasename[i] != '/'
442
&& pszBasename[i] != '\\';
445
if( pszBasename[i] == '.' )
446
pszBasename[i] = '\0';
448
pszFullname = (char *) malloc(strlen(pszBasename) + 5);
449
sprintf( pszFullname, "%s.dbf", pszBasename );
452
/* -------------------------------------------------------------------- */
453
/* Create the file. */
454
/* -------------------------------------------------------------------- */
455
fp = fopen( pszFullname, "wb" );
462
fp = fopen( pszFullname, "rb+" );
468
/* -------------------------------------------------------------------- */
469
/* Create the info structure. */
470
/* -------------------------------------------------------------------- */
471
psDBF = (DBFHandle) malloc(sizeof(DBFInfo));
476
psDBF->nRecordLength = 1;
477
psDBF->nHeaderLength = 33;
479
psDBF->panFieldOffset = NULL;
480
psDBF->panFieldSize = NULL;
481
psDBF->panFieldDecimals = NULL;
482
psDBF->pachFieldType = NULL;
483
psDBF->pszHeader = NULL;
485
psDBF->nCurrentRecord = -1;
486
psDBF->bCurrentRecordModified = FALSE;
487
psDBF->pszCurrentRecord = NULL;
489
psDBF->bNoHeader = TRUE;
494
/************************************************************************/
497
/* Add a field to a newly created .dbf file before any records */
499
/************************************************************************/
501
int DBFAddField(DBFHandle psDBF, const char * pszFieldName,
502
DBFFieldType eType, int nWidth, int nDecimals )
508
/* -------------------------------------------------------------------- */
509
/* Do some checking to ensure we can add records to this file. */
510
/* -------------------------------------------------------------------- */
511
if( psDBF->nRecords > 0 )
514
if( !psDBF->bNoHeader )
517
if( eType != FTDouble && nDecimals != 0 )
520
/* -------------------------------------------------------------------- */
521
/* SfRealloc all the arrays larger to hold the additional field */
523
/* -------------------------------------------------------------------- */
526
psDBF->panFieldOffset = (int *)
527
SfRealloc( psDBF->panFieldOffset, sizeof(int) * psDBF->nFields );
529
psDBF->panFieldSize = (int *)
530
SfRealloc( psDBF->panFieldSize, sizeof(int) * psDBF->nFields );
532
psDBF->panFieldDecimals = (int *)
533
SfRealloc( psDBF->panFieldDecimals, sizeof(int) * psDBF->nFields );
535
psDBF->pachFieldType = (char *)
536
SfRealloc( psDBF->pachFieldType, sizeof(char) * psDBF->nFields );
538
/* -------------------------------------------------------------------- */
539
/* Assign the new field information fields. */
540
/* -------------------------------------------------------------------- */
541
psDBF->panFieldOffset[psDBF->nFields-1] = psDBF->nRecordLength;
542
psDBF->nRecordLength += nWidth;
543
psDBF->panFieldSize[psDBF->nFields-1] = nWidth;
544
psDBF->panFieldDecimals[psDBF->nFields-1] = nDecimals;
546
if( eType == FTString )
547
psDBF->pachFieldType[psDBF->nFields-1] = 'C';
549
psDBF->pachFieldType[psDBF->nFields-1] = 'N';
551
/* -------------------------------------------------------------------- */
552
/* Extend the required header information. */
553
/* -------------------------------------------------------------------- */
554
psDBF->nHeaderLength += 32;
555
psDBF->bUpdated = FALSE;
557
psDBF->pszHeader = (char *) SfRealloc(psDBF->pszHeader,psDBF->nFields*32);
559
pszFInfo = psDBF->pszHeader + 32 * (psDBF->nFields-1);
561
for( i = 0; i < 32; i++ )
564
if( strlen(pszFieldName) < 10 )
565
strncpy( pszFInfo, pszFieldName, strlen(pszFieldName));
567
strncpy( pszFInfo, pszFieldName, 10);
569
pszFInfo[11] = psDBF->pachFieldType[psDBF->nFields-1];
571
if( eType == FTString )
573
pszFInfo[16] = nWidth % 256;
574
pszFInfo[17] = nWidth / 256;
578
pszFInfo[16] = nWidth;
579
pszFInfo[17] = nDecimals;
582
/* -------------------------------------------------------------------- */
583
/* Make the current record buffer appropriately larger. */
584
/* -------------------------------------------------------------------- */
585
psDBF->pszCurrentRecord = (char *) SfRealloc(psDBF->pszCurrentRecord,
586
psDBF->nRecordLength);
588
return( psDBF->nFields-1 );
591
/************************************************************************/
592
/* DBFReadAttribute() */
594
/* Read one of the attribute fields of a record. */
595
/************************************************************************/
597
static void *DBFReadAttribute(DBFHandle psDBF, int hEntity, int iField,
603
void *pReturnField = NULL;
605
static double dDoubleField;
607
/* -------------------------------------------------------------------- */
608
/* Have we read the record? */
609
/* -------------------------------------------------------------------- */
610
if( hEntity < 0 || hEntity >= psDBF->nRecords )
613
if( psDBF->nCurrentRecord != hEntity )
615
DBFFlushRecord( psDBF );
617
nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;
619
fseek( psDBF->fp, nRecordOffset, 0 );
620
fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );
622
psDBF->nCurrentRecord = hEntity;
625
pabyRec = (uchar *) psDBF->pszCurrentRecord;
627
/* -------------------------------------------------------------------- */
628
/* Ensure our field buffer is large enough to hold this buffer. */
629
/* -------------------------------------------------------------------- */
630
if( psDBF->panFieldSize[iField]+1 > nStringFieldLen )
632
nStringFieldLen = psDBF->panFieldSize[iField]*2 + 10;
633
pszStringField = (char *) SfRealloc(pszStringField,nStringFieldLen);
636
/* -------------------------------------------------------------------- */
637
/* Extract the requested field. */
638
/* -------------------------------------------------------------------- */
639
strncpy( pszStringField, pabyRec+psDBF->panFieldOffset[iField],
640
psDBF->panFieldSize[iField] );
641
pszStringField[psDBF->panFieldSize[iField]] = '\0';
643
pReturnField = pszStringField;
645
/* -------------------------------------------------------------------- */
646
/* Decode the field. */
647
/* -------------------------------------------------------------------- */
648
if( chReqType == 'N' )
650
dDoubleField = atof(pszStringField);
652
pReturnField = &dDoubleField;
655
/* -------------------------------------------------------------------- */
656
/* Should we trim white space off the string attribute value? */
657
/* -------------------------------------------------------------------- */
658
#ifdef TRIM_DBF_WHITESPACE
661
char *pchSrc, *pchDst;
663
pchDst = pchSrc = pszStringField;
664
while( *pchSrc == ' ' )
667
while( *pchSrc != '\0' )
668
*(pchDst++) = *(pchSrc++);
671
while( *(--pchDst) == ' ' && pchDst != pszStringField )
677
return( pReturnField );
680
/************************************************************************/
681
/* DBFReadIntAttribute() */
683
/* Read an integer attribute. */
684
/************************************************************************/
686
int DBFReadIntegerAttribute( DBFHandle psDBF, int iRecord, int iField )
691
pdValue = (double *) DBFReadAttribute( psDBF, iRecord, iField, 'N' );
693
return( (int) *pdValue );
696
/************************************************************************/
697
/* DBFReadDoubleAttribute() */
699
/* Read a double attribute. */
700
/************************************************************************/
702
double DBFReadDoubleAttribute( DBFHandle psDBF, int iRecord, int iField )
707
pdValue = (double *) DBFReadAttribute( psDBF, iRecord, iField, 'N' );
712
/************************************************************************/
713
/* DBFReadStringAttribute() */
715
/* Read a string attribute. */
716
/************************************************************************/
718
const char *DBFReadStringAttribute( DBFHandle psDBF, int iRecord, int iField )
721
return( (const char *) DBFReadAttribute( psDBF, iRecord, iField, 'C' ) );
724
/************************************************************************/
725
/* DBFGetFieldCount() */
727
/* Return the number of fields in this table. */
728
/************************************************************************/
730
int DBFGetFieldCount( DBFHandle psDBF )
733
return( psDBF->nFields );
736
/************************************************************************/
737
/* DBFGetRecordCount() */
739
/* Return the number of records in this table. */
740
/************************************************************************/
742
int DBFGetRecordCount( DBFHandle psDBF )
745
return( psDBF->nRecords );
748
/************************************************************************/
749
/* DBFGetFieldInfo() */
751
/* Return any requested information about the field. */
752
/************************************************************************/
754
DBFFieldType DBFGetFieldInfo( DBFHandle psDBF, int iField, char * pszFieldName,
755
int * pnWidth, int * pnDecimals )
758
if( iField < 0 || iField >= psDBF->nFields )
761
if( pnWidth != NULL )
762
*pnWidth = psDBF->panFieldSize[iField];
764
if( pnDecimals != NULL )
765
*pnDecimals = psDBF->panFieldDecimals[iField];
767
if( pszFieldName != NULL )
771
strncpy( pszFieldName, (char *) psDBF->pszHeader+iField*32, 11 );
772
pszFieldName[11] = '\0';
773
for( i = 10; i > 0 && pszFieldName[i] == ' '; i-- )
774
pszFieldName[i] = '\0';
777
if( psDBF->pachFieldType[iField] == 'N'
778
|| psDBF->pachFieldType[iField] == 'F'
779
|| psDBF->pachFieldType[iField] == 'D' )
781
if( psDBF->panFieldDecimals[iField] > 0 )
792
/************************************************************************/
793
/* DBFWriteAttribute() */
795
/* Write an attribute record to the file. */
796
/************************************************************************/
798
static int DBFWriteAttribute(DBFHandle psDBF, int hEntity, int iField,
802
int nRecordOffset, i, j;
804
char szSField[40], szFormat[12];
806
/* -------------------------------------------------------------------- */
807
/* Is this a valid record? */
808
/* -------------------------------------------------------------------- */
809
if( hEntity < 0 || hEntity > psDBF->nRecords )
812
if( psDBF->bNoHeader )
813
DBFWriteHeader(psDBF);
815
/* -------------------------------------------------------------------- */
816
/* Is this a brand new record? */
817
/* -------------------------------------------------------------------- */
818
if( hEntity == psDBF->nRecords )
820
DBFFlushRecord( psDBF );
823
for( i = 0; i < psDBF->nRecordLength; i++ )
824
psDBF->pszCurrentRecord[i] = ' ';
826
psDBF->nCurrentRecord = hEntity;
829
/* -------------------------------------------------------------------- */
830
/* Is this an existing record, but different than the last one */
832
/* -------------------------------------------------------------------- */
833
if( psDBF->nCurrentRecord != hEntity )
835
DBFFlushRecord( psDBF );
837
nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;
839
fseek( psDBF->fp, nRecordOffset, 0 );
840
fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );
842
psDBF->nCurrentRecord = hEntity;
845
pabyRec = (uchar *) psDBF->pszCurrentRecord;
847
/* -------------------------------------------------------------------- */
848
/* Assign all the record fields. */
849
/* -------------------------------------------------------------------- */
850
switch( psDBF->pachFieldType[iField] )
855
if( psDBF->panFieldDecimals[iField] == 0 )
857
sprintf( szFormat, "%%%dd", psDBF->panFieldSize[iField] );
858
sprintf(szSField, szFormat, (int) *((double *) pValue) );
859
if( strlen(szSField) > psDBF->panFieldSize[iField] )
860
szSField[psDBF->panFieldSize[iField]] = '\0';
862
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
863
szSField, strlen(szSField) );
867
sprintf( szFormat, "%%%d.%df",
868
psDBF->panFieldSize[iField],
869
psDBF->panFieldDecimals[iField] );
870
sprintf(szSField, szFormat, *((double *) pValue) );
871
if( strlen(szSField) > psDBF->panFieldSize[iField] )
872
szSField[psDBF->panFieldSize[iField]] = '\0';
873
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
874
szSField, strlen(szSField) );
879
if( strlen((char *) pValue) > psDBF->panFieldSize[iField] )
880
j = psDBF->panFieldSize[iField];
883
memset( pabyRec+psDBF->panFieldOffset[iField], ' ',
884
psDBF->panFieldSize[iField] );
885
j = strlen((char *) pValue);
888
strncpy((char *) (pabyRec+psDBF->panFieldOffset[iField]),
889
(char *) pValue, j );
893
psDBF->bCurrentRecordModified = TRUE;
894
psDBF->bUpdated = TRUE;
899
/************************************************************************/
900
/* DBFWriteDoubleAttribute() */
902
/* Write a double attribute. */
903
/************************************************************************/
905
int DBFWriteDoubleAttribute( DBFHandle psDBF, int iRecord, int iField,
909
return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) &dValue ) );
912
/************************************************************************/
913
/* DBFWriteIntegerAttribute() */
915
/* Write a integer attribute. */
916
/************************************************************************/
918
int DBFWriteIntegerAttribute( DBFHandle psDBF, int iRecord, int iField,
922
double dValue = nValue;
924
return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) &dValue ) );
927
/************************************************************************/
928
/* DBFWriteStringAttribute() */
930
/* Write a string attribute. */
931
/************************************************************************/
933
int DBFWriteStringAttribute( DBFHandle psDBF, int iRecord, int iField,
934
const char * pszValue )
937
return( DBFWriteAttribute( psDBF, iRecord, iField, (void *) pszValue ) );
940
/************************************************************************/
941
/* DBFWriteTuple() */
943
/* Write an attribute record to the file. */
944
/************************************************************************/
946
int DBFWriteTuple(DBFHandle psDBF, int hEntity, void * pRawTuple )
949
int nRecordOffset, i;
952
/* -------------------------------------------------------------------- */
953
/* Is this a valid record? */
954
/* -------------------------------------------------------------------- */
955
if( hEntity < 0 || hEntity > psDBF->nRecords )
958
if( psDBF->bNoHeader )
959
DBFWriteHeader(psDBF);
961
/* -------------------------------------------------------------------- */
962
/* Is this a brand new record? */
963
/* -------------------------------------------------------------------- */
964
if( hEntity == psDBF->nRecords )
966
DBFFlushRecord( psDBF );
969
for( i = 0; i < psDBF->nRecordLength; i++ )
970
psDBF->pszCurrentRecord[i] = ' ';
972
psDBF->nCurrentRecord = hEntity;
975
/* -------------------------------------------------------------------- */
976
/* Is this an existing record, but different than the last one */
978
/* -------------------------------------------------------------------- */
979
if( psDBF->nCurrentRecord != hEntity )
981
DBFFlushRecord( psDBF );
983
nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;
985
fseek( psDBF->fp, nRecordOffset, 0 );
986
fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );
988
psDBF->nCurrentRecord = hEntity;
991
pabyRec = (uchar *) psDBF->pszCurrentRecord;
993
memcpy ( pabyRec, pRawTuple, psDBF->nRecordLength );
995
psDBF->bCurrentRecordModified = TRUE;
996
psDBF->bUpdated = TRUE;
1001
/************************************************************************/
1002
/* DBFReadTuple() */
1004
/* Read one of the attribute fields of a record. */
1005
/************************************************************************/
1007
const char *DBFReadTuple(DBFHandle psDBF, int hEntity )
1012
static char *pReturnTuple = NULL;
1014
static int nTupleLen = 0;
1016
/* -------------------------------------------------------------------- */
1017
/* Have we read the record? */
1018
/* -------------------------------------------------------------------- */
1019
if( hEntity < 0 || hEntity >= psDBF->nRecords )
1022
if( psDBF->nCurrentRecord != hEntity )
1024
DBFFlushRecord( psDBF );
1026
nRecordOffset = psDBF->nRecordLength * hEntity + psDBF->nHeaderLength;
1028
fseek( psDBF->fp, nRecordOffset, 0 );
1029
fread( psDBF->pszCurrentRecord, psDBF->nRecordLength, 1, psDBF->fp );
1031
psDBF->nCurrentRecord = hEntity;
1034
pabyRec = (uchar *) psDBF->pszCurrentRecord;
1036
if ( nTupleLen < psDBF->nRecordLength) {
1037
nTupleLen = psDBF->nRecordLength;
1038
pReturnTuple = (char *) SfRealloc(pReturnTuple, psDBF->nRecordLength);
1041
memcpy ( pReturnTuple, pabyRec, psDBF->nRecordLength );
1043
return( pReturnTuple );
1046
/************************************************************************/
1047
/* DBFCloneEmpty() */
1049
/* Read one of the attribute fields of a record. */
1050
/************************************************************************/
1052
DBFHandle DBFCloneEmpty(DBFHandle psDBF, const char * pszFilename )
1056
newDBF = DBFCreate ( pszFilename );
1057
if ( newDBF == NULL ) return ( NULL );
1059
newDBF->pszHeader = (void *) malloc ( 32 * psDBF->nFields );
1060
memcpy ( newDBF->pszHeader, psDBF->pszHeader, 32 * psDBF->nFields );
1062
newDBF->nFields = psDBF->nFields;
1063
newDBF->nRecordLength = psDBF->nRecordLength;
1064
newDBF->nHeaderLength = psDBF->nHeaderLength;
1066
newDBF->panFieldOffset = (void *) malloc ( sizeof(int) * psDBF->nFields );
1067
memcpy ( newDBF->panFieldOffset, psDBF->panFieldOffset, sizeof(int) * psDBF->nFields );
1068
newDBF->panFieldSize = (void *) malloc ( sizeof(int) * psDBF->nFields );
1069
memcpy ( newDBF->panFieldSize, psDBF->panFieldSize, sizeof(int) * psDBF->nFields );
1070
newDBF->panFieldDecimals = (void *) malloc ( sizeof(int) * psDBF->nFields );
1071
memcpy ( newDBF->panFieldDecimals, psDBF->panFieldDecimals, sizeof(int) * psDBF->nFields );
1072
newDBF->pachFieldType = (void *) malloc ( sizeof(int) * psDBF->nFields );
1073
memcpy ( newDBF->pachFieldType, psDBF->pachFieldType, sizeof(int) * psDBF->nFields );
1075
newDBF->bNoHeader = TRUE;
1076
newDBF->bUpdated = TRUE;
1078
DBFWriteHeader ( newDBF );
1079
DBFClose ( newDBF );
1081
newDBF = DBFOpen ( pszFilename, "rb+" );
added
removed
src/plugins/grid_maker/dbfopen.c
