My Project  debian-1:4.1.1-p2+ds-4
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 "omalloc/omalloc.h"
18 # include "Singular/tok.h"
19 # include "Singular/ipid.h"
20 # include "Singular/links/silink.h"
21 # include "Singular/links/sing_dbm.h"
22 
23 // #ifdef __CYGWIN__
24 // # define USE_GDBM
25 // # define BLOCKSIZE 1
26 // # define GDBM_STATIC
27 // # include <gdbm.h>
28 // #endif
29 
30 #ifdef USE_GDBM
31 typedef struct {
32  GDBM_FILE db; // pointer to open database
33  int first; // firstkey to look for?
34  datum actual; // the actual key
35 } GDBM_info;
36 
37 //**************************************************************************/
38 LINKAGE BOOLEAN dbOpen(si_link l, short flag, leftv u)
39 {
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  omFree(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 //**************************************************************************/
107 static datum d_value;
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"
277 typedef struct {
278  DBM *db; // pointer to open database
279  int first; // firstkey to look for?
280 } DBM_info;
281 
282 //**************************************************************************/
283 LINKAGE 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  omFree(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 //**************************************************************************/
332 static datum d_value;
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  register 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 */
FALSE
#define FALSE
Definition: auxiliary.h:94
omalloc.h
sleftv::Data
void * Data()
Definition: subexpr.cc:1133
omFree
#define omFree(addr)
Definition: omAllocDecl.h:259
dbRead2
LINKAGE leftv dbRead2(si_link l, leftv key)
Definition: sing_dbm.cc:332
DBM
Definition: ndbm.h:53
ndbm.h
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
dbm_nextkey
datum dbm_nextkey(DBM *db)
Definition: ndbm.cc:260
STRING_CMD
Definition: tok.h:182
dbm_error
#define dbm_error(db)
Definition: ndbm.h:74
dbm_store
int dbm_store(DBM *db, datum key, datum dat, int replace)
Definition: ndbm.cc:167
dbRead1
LINKAGE leftv dbRead1(si_link l)
Definition: sing_dbm.cc:378
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:261
DBM_REPLACE
#define DBM_REPLACE
Definition: ndbm.h:91
omAlloc0Bin
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:204
sleftv
Class used for (list of) interpreter objects.
Definition: subexpr.h:81
b
CanonicalForm b
Definition: cfModGcd.cc:4044
datum
Definition: ndbm.h:82
leftv
sleftv * leftv
Definition: structs.h:59
DBM_info
Definition: sing_dbm.cc:276
dbOpen
LINKAGE BOOLEAN dbOpen(si_link l, short flag, leftv)
Definition: sing_dbm.cc:282
dbWrite
LINKAGE BOOLEAN dbWrite(si_link l, leftv key)
Definition: sing_dbm.cc:383
TRUE
#define TRUE
Definition: auxiliary.h:98
PrintS
void PrintS(const char *s)
Definition: reporter.cc:283
dbm_delete
int dbm_delete(DBM *db, datum key)
Definition: ndbm.cc:139
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:258
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
DBM_info::first
int first
Definition: sing_dbm.cc:279
d_value
static datum d_value
Definition: sing_dbm.cc:331
sing_dbm.h
mod2.h
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
DBM_info::db
DBM * db
Definition: sing_dbm.cc:278
datum::dptr
char * dptr
Definition: ndbm.h:83
Print
#define Print
Definition: emacs.cc:79
dbm_close
void dbm_close(DBM *db)
Definition: ndbm.cc:97
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:188
dbClose
LINKAGE BOOLEAN dbClose(si_link l)
Definition: sing_dbm.cc:319
tok.h
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
sleftv::Typ
int Typ()
Definition: subexpr.cc:991
dbm_firstkey
datum dbm_firstkey(DBM *db)
Definition: ndbm.cc:252
NULL
#define NULL
Definition: omList.c:9
l
int l
Definition: cfEzgcd.cc:93
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
sleftv_bin
omBin sleftv_bin
Definition: subexpr.cc:45
dbm_fetch
datum dbm_fetch(DBM *db, datum key)
Definition: ndbm.cc:119
dbm_open
DBM * dbm_open(char *file, int flags, int mode)
Definition: ndbm.cc:59
LINKAGE
#define LINKAGE
Definition: mod2.h:137
ipid.h
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:209
if
if(yy_init)
Definition: libparse.cc:1417
sleftv::next
leftv next
Definition: subexpr.h:85
datum::dsize
int dsize
Definition: ndbm.h:84
dbm_clearerr
#define dbm_clearerr(db)
Definition: ndbm.h:76