source: git/Singular/links/sing_dbm.cc @ 01776f

spielwiese
Last change on this file since 01776f was 9617e9, checked in by Hans Schoenemann <hannes@…>, 6 years ago
clang warnings (register)
  • Property mode set to 100644
File size: 11.0 KB
Line 
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
31typedef 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//**************************************************************************/
38LINKAGE 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)
82      SI_LINK_SET_W_OPEN_P(l);
83    else
84      SI_LINK_SET_R_OPEN_P(l);
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//**************************************************************************/
95LINKAGE BOOLEAN dbClose(si_link l)
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;
102  SI_LINK_SET_CLOSE_P(l);
103  return FALSE;
104}
105
106//**************************************************************************/
107static datum d_value;
108LINKAGE leftv dbRead2(si_link l, leftv key)
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);
137      v=(leftv)omAlloc0Bin(sleftv_bin);
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
178    v=(leftv)omAlloc0Bin(sleftv_bin);
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}
194LINKAGE leftv dbRead1(si_link l)
195{
196  return dbRead2(l,NULL);
197}
198//**************************************************************************/
199LINKAGE BOOLEAN dbWrite(si_link l, leftv key)
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";
294    flag|=SI_LINK_WRITE|SI_LINK_READ;
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)
308      SI_LINK_SET_RW_OPEN_P(l);
309    else
310      SI_LINK_SET_R_OPEN_P(l);
311    l->data=(void *)(db);
312    omFree(l->mode);
313    l->mode=omStrDup(mode);
314    return FALSE;
315  }
316  return TRUE;
317}
318
319//**************************************************************************/
320LINKAGE BOOLEAN dbClose(si_link l)
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;
327  SI_LINK_SET_CLOSE_P(l);
328  return FALSE;
329}
330
331//**************************************************************************/
332static datum d_value;
333LINKAGE leftv dbRead2(si_link l, leftv key)
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);
346      v=(leftv)omAlloc0Bin(sleftv_bin);
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
363    v=(leftv)omAlloc0Bin(sleftv_bin);
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}
379LINKAGE leftv dbRead1(si_link l)
380{
381  return dbRead2(l,NULL);
382}
383//**************************************************************************/
384LINKAGE BOOLEAN dbWrite(si_link l, leftv key)
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 */
Note: See TracBrowser for help on using the repository browser.