1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#ifdef I_DBM
# include <dbm.h>
#else
# ifdef I_RPCSVC_DBM
# include <rpcsvc/dbm.h>
# endif
#endif
#ifndef HAS_DBMINIT_PROTO
int dbminit(char* filename);
int dbmclose(void);
datum fetch(datum key);
int store(datum key, datum dat);
int odelete(datum key); /* Cannot be delete() because of C++. */
datum firstkey(void);
datum nextkey(datum key);
#endif
#ifdef DBM_BUG_DUPLICATE_FREE
/*
* DBM on at least Ultrix and HPUX call dbmclose() from dbminit(),
* resulting in duplicate free() because dbmclose() does *not*
* check if it has already been called for this DBM.
* If some malloc/free calls have been done between dbmclose() and
* the next dbminit(), the memory might be used for something else when
* it is freed.
* Verified to work on ultrix4.3. Probably will work on HP/UX.
* Set DBM_BUG_DUPLICATE_FREE in the extension hint file.
*/
/* Close the previous dbm, and fail to open a new dbm */
#define dbmclose() ((void) dbminit("/non/exist/ent"))
#endif
#include <fcntl.h>
typedef struct {
void * dbp ;
SV * filter_fetch_key ;
SV * filter_store_key ;
SV * filter_fetch_value ;
SV * filter_store_value ;
int filtering ;
} ODBM_File_type;
typedef ODBM_File_type * ODBM_File ;
typedef datum datum_key ;
typedef datum datum_key_copy ;
typedef datum datum_value ;
#define odbm_FETCH(db,key) fetch(key)
#define odbm_STORE(db,key,value,flags) store(key,value)
#define odbm_DELETE(db,key) odelete(key)
#define odbm_FIRSTKEY(db) firstkey()
#define odbm_NEXTKEY(db,key) nextkey(key)
#define MY_CXT_KEY "ODBM_File::_guts" XS_VERSION
typedef struct {
int x_dbmrefcnt;
} my_cxt_t;
START_MY_CXT
#define dbmrefcnt (MY_CXT.x_dbmrefcnt)
#ifndef DBM_REPLACE
#define DBM_REPLACE 0
#endif
MODULE = ODBM_File PACKAGE = ODBM_File PREFIX = odbm_
BOOT:
{
MY_CXT_INIT;
}
ODBM_File
odbm_TIEHASH(dbtype, filename, flags, mode)
char * dbtype
char * filename
int flags
int mode
CODE:
{
char *tmpbuf;
void * dbp ;
dMY_CXT;
if (dbmrefcnt++)
croak("Old dbm can only open one database");
Newx(tmpbuf, strlen(filename) + 5, char);
SAVEFREEPV(tmpbuf);
sprintf(tmpbuf,"%s.dir",filename);
if (stat(tmpbuf, &PL_statbuf) < 0) {
if (flags & O_CREAT) {
if (mode < 0 || close(creat(tmpbuf,mode)) < 0)
croak("ODBM_File: Can't create %s", filename);
sprintf(tmpbuf,"%s.pag",filename);
if (close(creat(tmpbuf,mode)) < 0)
croak("ODBM_File: Can't create %s", filename);
}
else
croak("ODBM_FILE: Can't open %s", filename);
}
dbp = (void*)(dbminit(filename) >= 0 ? &dbmrefcnt : 0);
RETVAL = (ODBM_File)safemalloc(sizeof(ODBM_File_type)) ;
Zero(RETVAL, 1, ODBM_File_type) ;
RETVAL->dbp = dbp ;
ST(0) = sv_mortalcopy(&PL_sv_undef);
sv_setptrobj(ST(0), RETVAL, dbtype);
}
void
DESTROY(db)
ODBM_File db
PREINIT:
dMY_CXT;
CODE:
dbmrefcnt--;
dbmclose();
safefree(db);
datum_value
odbm_FETCH(db, key)
ODBM_File db
datum_key_copy key
int
odbm_STORE(db, key, value, flags = DBM_REPLACE)
ODBM_File db
datum_key key
datum_value value
int flags
CLEANUP:
if (RETVAL) {
if (RETVAL < 0 && errno == EPERM)
croak("No write permission to odbm file");
croak("odbm store returned %d, errno %d, key \"%s\"",
RETVAL,errno,key.dptr);
}
int
odbm_DELETE(db, key)
ODBM_File db
datum_key key
datum_key
odbm_FIRSTKEY(db)
ODBM_File db
datum_key
odbm_NEXTKEY(db, key)
ODBM_File db
datum_key key
#define setFilter(type) \
{ \
if (db->type) \
RETVAL = sv_mortalcopy(db->type) ; \
ST(0) = RETVAL ; \
if (db->type && (code == &PL_sv_undef)) { \
SvREFCNT_dec(db->type) ; \
db->type = Nullsv ; \
} \
else if (code) { \
if (db->type) \
sv_setsv(db->type, code) ; \
else \
db->type = newSVsv(code) ; \
} \
}
SV *
filter_fetch_key(db, code)
ODBM_File db
SV * code
SV * RETVAL = &PL_sv_undef ;
CODE:
DBM_setFilter(db->filter_fetch_key, code) ;
SV *
filter_store_key(db, code)
ODBM_File db
SV * code
SV * RETVAL = &PL_sv_undef ;
CODE:
DBM_setFilter(db->filter_store_key, code) ;
SV *
filter_fetch_value(db, code)
ODBM_File db
SV * code
SV * RETVAL = &PL_sv_undef ;
CODE:
DBM_setFilter(db->filter_fetch_value, code) ;
SV *
filter_store_value(db, code)
ODBM_File db
SV * code
SV * RETVAL = &PL_sv_undef ;
CODE:
DBM_setFilter(db->filter_store_value, code) ;
|
