source: git/Singular/sing_dbm.cc @ fcafdb

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