My Project
Loading...
Searching...
No Matches
sing_dbm.cc
Go to the documentation of this file.
1/****************************************
2* Computer Algebra System SINGULAR *
3****************************************/
4
5//**************************************************************************/
6// 'sing_dbm.cc' containes command to handle dbm-files under
7// Singular.
8//
9//**************************************************************************/
10
11#include "kernel/mod2.h"
12
13# include <fcntl.h>
14
15#ifdef HAVE_DBM
16
17# include "Singular/tok.h"
18# include "Singular/ipid.h"
21
22// #ifdef __CYGWIN__
23// # define USE_GDBM
24// # define BLOCKSIZE 1
25// # define GDBM_STATIC
26// # include <gdbm.h>
27// #endif
28
29#ifdef USE_GDBM
30typedef struct {
31 GDBM_FILE db; // pointer to open database
32 int first; // firstkey to look for?
33 datum actual; // the actual key
34} GDBM_info;
35
36//**************************************************************************/
37LINKAGE BOOLEAN dbOpen(si_link l, short flag, leftv u)
38{
39 if (FE_OPT_NO_SHELL_FLAG) {WerrorS("no links allowed");return TRUE;}
40 char *mode = "r";
41 GDBM_info *db;
42 datum d_key;
43 // int dbm_flags = O_RDONLY | O_CREAT; // open database readonly as default
44 int read_write= GDBM_READER;
45
46 if(flag & SI_LINK_WRITE)
47 {
48 // if((l->mode==NULL)
49// || ((l->mode[0]!='w')&&(l->mode[1]!='w')))
50// {
51// // request w- open, but mode is not "w" nor "rw" => fail
52// return TRUE;
53// }
54 // dbm_flags = O_RDWR | O_CREAT;
55 read_write = GDBM_WRCREAT | GDBM_NOLOCK;
56 mode = "rw";
57 }
58 if(flag & SI_LINK_READ)
59 {
60 if (strcmp(l->mode,"rw")==0) mode="rw";
61 }
62 //if (((db = (DBM_info *)omAlloc(sizeof *db)) != NULL)
63 //&&((db->db = dbm_open(l->name, dbm_flags, 0664 )) != NULL ))
64 db = (GDBM_info *)omAlloc0(sizeof *db);
65 if((db->db = gdbm_open(l->name, BLOCKSIZE, read_write, 0664, 0)) != NULL )
66 {
67// if (db->first) // first created?
68// {
69// db->actual=gdbm_firstkey(db->db);
70// }
71// else
72// {
73// d_key=db->actual;
74// if (d_key.dptr!=NULL)
75// {
76// db->actual=gdbm_nextkey(db->db,db->actual);
77// }
78// else { db->actual=gdbm_firstkey(db->db); }
79// }
80 db->first=1;
81 if(flag & SI_LINK_WRITE)
83 else
85 l->data=(void *)(db);
86 omFreeBinAddr(l->mode);
87 l->mode=omStrDup(mode);
88 return FALSE;
89 }
90 Print("%d/%s",gdbm_errno,gdbm_strerror(gdbm_errno));
91 return TRUE;
92}
93
94//**************************************************************************/
96{
97 GDBM_info *db = (GDBM_info *)l->data;
98 gdbm_sync(db->db);
99 gdbm_close(db->db);
100 omFreeSize((ADDRESS)db,(sizeof *db));
101 l->data=NULL;
103 return FALSE;
104}
105
106//**************************************************************************/
109{
110 GDBM_info *db = (GDBM_info *)l->data;
111 // GDBM_info *db;
112// db = (GDBM_info *)omAlloc0(sizeof *db);
113// db = (GDBM_info *)l->data;
114 leftv v=NULL;
115 datum d_key;
116 int flag;
117
118 if (!SI_LINK_R_OPEN_P(l)) //exceptions
119 // if (strcmp(l->mode,"rw")==0) //rw-mode
120 {
121 if (!SI_LINK_CLOSE_P(l))
122 {
123 if (!dbClose(l)) {PrintS("cannot close link!\n");}
124 }
125 //(SI_LINK_CLOSE_P(l)) automatically
126 if (dbOpen(l, SI_LINK_READ)) return NULL;
127 }
128 if (SI_LINK_RW_OPEN_P(l)) {PrintS("I/O Error!\n");}
129
130 if(key!=NULL)
131 {
132 if (key->Typ()==STRING_CMD)
133 {
134 d_key.dptr = (char*)key->Data();
135 d_key.dsize = strlen(d_key.dptr)+1;
136 d_value = gdbm_fetch(db->db, d_key);
138 if (d_value.dptr!=NULL) v->data=omStrDup(d_value.dptr);
139 else v->data=omStrDup("");
140 v->rtyp=STRING_CMD;
141 }
142 else
143 {
144 WerrorS("read(`GDBM link`,`string`) expected");
145 }
146 }
147 else
148 {
149 if (db->first)
150 {
151 db->first=0;
152 d_key = gdbm_firstkey(db->db);
153 // db->actual=d_key;
154// Print("firstkey:%s\n",d_key.dptr);
155 }
156 else
157 {
158 if (db->actual.dptr==NULL)
159 {
160 db->actual=gdbm_firstkey(db->db);
161 }
162 d_key = gdbm_nextkey(db->db,db->actual);
163 db->actual=d_key;
164 if (d_key.dptr==NULL)
165 {
166 db->first=1;
167 // Print("nextkey:NULL\n");
168 }
169 // else
170// Print("nextkey:%s\n",d_key.dptr);
171 }
172
173 if (d_key.dptr!=NULL)
174 d_value = gdbm_fetch(db->db, d_key);
175 else
176 d_value.dptr=NULL;
177
179 v->rtyp=STRING_CMD;
180 if (d_value.dptr!=NULL)
181 {
182 v->data=omStrDup(d_key.dptr);
183 db->first = 0;
184 }
185 else
186 {
187 v->data=omStrDup("");
188 // db->first = 1;
189 }
190
191 }
192 return v;
193}
195{
196 return dbRead2(l,NULL);
197}
198//**************************************************************************/
200{
201 GDBM_info *db = (GDBM_info *)l->data;
202 // GDBM_info *db;
203// db = (GDBM_info *)omAlloc0(sizeof *db);
204// db = (GDBM_info *)l->data;
205 BOOLEAN b=TRUE;
206 REGISTER int ret;
207
208 if (strcmp(l->mode,"rw")!=0) // r-mode
209 {
210 PrintS("Write error on readonly source\n");
211 }
212 else //rw-mode
213 {
214 if (!SI_LINK_W_OPEN_P(l)) //exceptions
215 {
216 if (!SI_LINK_CLOSE_P(l))
217 {
218 if (!dbClose(l)) {PrintS("close error\n");};
219 }
220 if (!dbOpen(l,SI_LINK_WRITE)) {PrintS("open_for_write error\n");}
221 }
222 }
223
224 if((key!=NULL) && (key->Typ()==STRING_CMD) )
225 {
226 if (key->next!=NULL) // have a second parameter ?
227 {
228 if(key->next->Typ()==STRING_CMD) // replace (key,value)
229 {
230 datum d_key, d_value;
231
232 d_key.dptr = (char *)key->Data();
233 d_key.dsize = strlen(d_key.dptr)+1;
234 d_value.dptr = (char *)key->next->Data();
235 d_value.dsize = strlen(d_value.dptr)+1;
236 ret = gdbm_store(db->db, d_key, d_value, GDBM_REPLACE);
237// db->actual=d_key;
238 if (ret==-1) {PrintS("reader calls gdbm_store!");}
239 if (ret==0)
240 { b=FALSE; }
241 else
242 {
243 // if(gdbm_error(db->db))
244 if (gdbm_errno != 0)
245 {
246 Werror("GDBM link I/O error: '%s' ", gdbm_errno);
247 // Print(gdbm_strerror(gdbm_errno));
248 //dbm_clearerr(db->db);
249 // gdbm_errno=0;
250 }
251 }
252 }
253 }
254 else
255 { // delete (key)
256 datum d_key;
257
258 d_key.dptr = (char *)key->Data();
259 d_key.dsize = strlen(d_key.dptr)+1;
260 // db->actual=gdbm_nextkey(db->db,d_key);
261 gdbm_delete(db->db, d_key);
262 b=FALSE;
263 }
264 }
265 else
266 {
267 WerrorS("write(`GDBM link`,`key string` [,`data string`]) expected");
268 }
269 gdbm_sync(db->db);
270 return b;
271}
272#endif /* USE_GDBM */
273
274#ifndef USE_GDBM
275/* These are the routines in dbm. */
276# include "ndbm.h"
277typedef struct {
278 DBM *db; // pointer to open database
279 int first; // firstkey to look for?
280} DBM_info;
281
282//**************************************************************************/
283LINKAGE BOOLEAN dbOpen(si_link l, short flag, leftv /*u*/)
284{
285 const char *mode = "r";
286 DBM_info *db;
287 int dbm_flags = O_RDONLY | O_CREAT; // open database readonly as default
288
289 if((l->mode!=NULL)
290 && ((l->mode[0]=='w')||(l->mode[1]=='w')))
291 {
292 dbm_flags = O_RDWR | O_CREAT;
293 mode = "rw";
295 }
296 else if(flag & SI_LINK_WRITE)
297 {
298 // request w- open, but mode is not "w" nor "rw" => fail
299 return TRUE;
300 }
301 //if (((db = (DBM_info *)omAlloc(sizeof *db)) != NULL)
302 //&&((db->db = dbm_open(l->name, dbm_flags, 0664 )) != NULL ))
303 db = (DBM_info *)omAlloc(sizeof *db);
304 if((db->db = dbm_open(l->name, dbm_flags, 0664 )) != NULL )
305 {
306 db->first=1;
307 if(flag & SI_LINK_WRITE)
309 else
311 l->data=(void *)(db);
312 omFreeBinAddr(l->mode);
313 l->mode=omStrDup(mode);
314 return FALSE;
315 }
316 return TRUE;
317}
318
319//**************************************************************************/
321{
322 DBM_info *db = (DBM_info *)l->data;
323
324 dbm_close(db->db);
325 omFreeSize((ADDRESS)db,(sizeof *db));
326 l->data=NULL;
328 return FALSE;
329}
330
331//**************************************************************************/
334{
335 DBM_info *db = (DBM_info *)l->data;
336 leftv v=NULL;
337 datum d_key;
338
339 if(key!=NULL)
340 {
341 if (key->Typ()==STRING_CMD)
342 {
343 d_key.dptr = (char*)key->Data();
344 d_key.dsize = strlen(d_key.dptr)+1;
345 d_value = dbm_fetch(db->db, d_key);
347 if (d_value.dptr!=NULL) v->data=omStrDup(d_value.dptr);
348 else v->data=omStrDup("");
349 v->rtyp=STRING_CMD;
350 }
351 else
352 {
353 WerrorS("read(`DBM link`,`string`) expected");
354 }
355 }
356 else
357 {
358 if(db->first)
359 d_value = dbm_firstkey((DBM *)db->db);
360 else
361 d_value = dbm_nextkey((DBM *)db->db);
362
364 v->rtyp=STRING_CMD;
365 if (d_value.dptr!=NULL)
366 {
367 v->data=omStrDup(d_value.dptr);
368 db->first = 0;
369 }
370 else
371 {
372 v->data=omStrDup("");
373 db->first = 1;
374 }
375
376 }
377 return v;
378}
380{
381 return dbRead2(l,NULL);
382}
383//**************************************************************************/
385{
386 DBM_info *db = (DBM_info *)l->data;
387 BOOLEAN b=TRUE;
388 int ret;
389
390 // database is opened
391 if((key!=NULL) && (key->Typ()==STRING_CMD) )
392 {
393 if (key->next!=NULL) // have a second parameter ?
394 {
395 if(key->next->Typ()==STRING_CMD) // replace (key,value)
396 {
397 datum d_key, d_value;
398
399 d_key.dptr = (char *)key->Data();
400 d_key.dsize = strlen(d_key.dptr)+1;
401 d_value.dptr = (char *)key->next->Data();
402 d_value.dsize = strlen(d_value.dptr)+1;
403 ret = dbm_store(db->db, d_key, d_value, DBM_REPLACE);
404 if(!ret )
405 b=FALSE;
406 else
407 {
408 if(dbm_error(db->db))
409 {
410 Werror("DBM link I/O error. Is '%s' readonly?", l->name);
411 dbm_clearerr(db->db);
412 }
413 }
414 }
415 }
416 else
417 { // delete (key)
418 datum d_key;
419
420 d_key.dptr = (char *)key->Data();
421 d_key.dsize = strlen(d_key.dptr)+1;
422 dbm_delete(db->db, d_key);
423 b=FALSE;
424 }
425 }
426 else
427 {
428 WerrorS("write(`DBM link`,`key string` [,`data string`]) expected");
429 }
430 return b;
431}
432//**************************************************************************/
433//char *dbStatus(si_link l, char *request)
434//{
435// if (strcmp(request, "read") == 0)
436// {
437// if (SI_LINK_R_OPEN_P(l))
438// return "ready";
439// else
440// return "not ready";
441// }
442// else if (strcmp(request, "write") == 0)
443// {
444// if (SI_LINK_W_OPEN_P(l))
445// return "ready";
446// else
447// return "not ready";
448// }
449// else return "unknown status request";
450//}
451//**************************************************************************/
452
453#endif /* USE_GDBM */
454#endif /* HAVE_DBM */
int BOOLEAN
Definition auxiliary.h:88
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
void * ADDRESS
Definition auxiliary.h:120
int l
Definition cfEzgcd.cc:100
CanonicalForm b
Definition cfModGcd.cc:4111
int Typ()
Definition subexpr.cc:1048
void * Data()
Definition subexpr.cc:1192
leftv next
Definition subexpr.h:86
#define Print
Definition emacs.cc:80
EXTERN_VAR BOOLEAN FE_OPT_NO_SHELL_FLAG
Definition extra.cc:170
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
void WerrorS(const char *s)
Definition feFopen.cc:24
#define STATIC_VAR
Definition globaldefs.h:7
EXTERN_VAR omBin sleftv_bin
Definition ipid.h:145
#define LINKAGE
Definition mod2.h:140
int dbm_store(DBM *db, datum key, datum dat, int replace)
Definition ndbm.cc:167
datum dbm_fetch(DBM *db, datum key)
Definition ndbm.cc:119
int dbm_delete(DBM *db, datum key)
Definition ndbm.cc:139
datum dbm_nextkey(DBM *db)
Definition ndbm.cc:260
datum dbm_firstkey(DBM *db)
Definition ndbm.cc:252
DBM * dbm_open(char *file, int flags, int mode)
Definition ndbm.cc:59
void dbm_close(DBM *db)
Definition ndbm.cc:97
char * dptr
Definition ndbm.h:84
#define dbm_clearerr(db)
Definition ndbm.h:77
#define dbm_error(db)
Definition ndbm.h:75
#define DBM_REPLACE
Definition ndbm.h:92
int dsize
Definition ndbm.h:85
Definition ndbm.h:54
Definition ndbm.h:83
#define omStrDup(s)
#define omFreeSize(addr, size)
#define omAlloc(size)
#define omAlloc0Bin(bin)
#define omAlloc0(size)
#define omFreeBinAddr(addr)
#define NULL
Definition omList.c:12
#define REGISTER
Definition omalloc.h:27
void PrintS(const char *s)
Definition reporter.cc:284
void Werror(const char *fmt,...)
Definition reporter.cc:189
LINKAGE BOOLEAN dbClose(si_link l)
Definition sing_dbm.cc:320
LINKAGE BOOLEAN dbWrite(si_link l, leftv key)
Definition sing_dbm.cc:384
LINKAGE leftv dbRead1(si_link l)
Definition sing_dbm.cc:379
LINKAGE BOOLEAN dbOpen(si_link l, short flag, leftv)
Definition sing_dbm.cc:283
int first
Definition sing_dbm.cc:279
DBM * db
Definition sing_dbm.cc:278
LINKAGE leftv dbRead2(si_link l, leftv key)
Definition sing_dbm.cc:333
STATIC_VAR datum d_value
Definition sing_dbm.cc:332
sleftv * leftv
Definition structs.h:53
@ STRING_CMD
Definition tok.h:187