74static VALUE rb_cGDBM, rb_eGDBMError, rb_eGDBMFatalError;
76#if SIZEOF_LONG > SIZEOF_INT
77#define TOO_LONG(n) ((long)(+(int)(n)) != (long)(n))
82#define RUBY_GDBM_RW_BIT 0x20000000
84#define MY_BLOCK_SIZE (2048)
85#define MY_FATAL_FUNC rb_gdbm_fatal
87NORETURN(
static void rb_gdbm_fatal(
const char *msg));
88NORETURN(
static void closed_dbm(
void));
91rb_gdbm_fatal(
const char *msg)
93 rb_raise(rb_eGDBMFatalError,
"%s", msg);
107#define GetDBM(obj, dbmp) do {\
108 TypedData_Get_Struct((obj), struct dbmdata, &dbm_type, (dbmp));\
109 if ((dbmp)->di_dbm == 0) closed_dbm();\
112#define GetDBM2(obj, dbmp, dbm) do {\
113 GetDBM((obj), (dbmp));\
114 (dbm) = (dbmp)->di_dbm;\
127memsize_dbm(
const void *
ptr)
130 size_t size =
sizeof(*dbmp);
132 size += DBM_SIZEOF_DBM;
138 {0, free_dbm, memsize_dbm,},
150fgdbm_close(
VALUE obj)
168fgdbm_closed(
VALUE obj)
180fgdbm_s_alloc(
VALUE klass)
222 else if (
NIL_P(vmode)) {
236 flags |= GDBM_CLOEXEC;
240 flags &= ~RUBY_GDBM_RW_BIT;
264 if (gdbm_errno == GDBM_FILE_OPEN_ERROR ||
265 gdbm_errno == GDBM_CANT_BE_READER ||
266 gdbm_errno == GDBM_CANT_BE_WRITER)
269 rb_raise(rb_eGDBMError,
"%s", gdbm_strerror(gdbm_errno));
302 VALUE obj = fgdbm_s_alloc(klass);
316rb_gdbm_fetch(GDBM_FILE dbm, datum
key)
321 val = gdbm_fetch(dbm,
key);
331rb_gdbm_fetch2(GDBM_FILE dbm,
VALUE keystr)
342 return rb_gdbm_fetch(dbm,
key);
352 return rb_gdbm_fetch2(dbm, keystr);
356rb_gdbm_firstkey(GDBM_FILE dbm)
361 key = gdbm_firstkey(dbm);
371rb_gdbm_nextkey(GDBM_FILE dbm,
VALUE keystr)
381 key2 = gdbm_nextkey(dbm,
key);
395 valstr = rb_gdbm_fetch3(obj, keystr);
413 return rb_gdbm_fetch3(obj, keystr);
426 VALUE keystr, valstr, ifnone;
429 valstr = fgdbm_fetch(obj, keystr, ifnone);
448 VALUE keystr, valstr2;
452 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
453 keystr = rb_gdbm_nextkey(dbm, keystr)) {
455 valstr2 = rb_gdbm_fetch2(dbm, keystr);
456 if (!
NIL_P(valstr2) &&
470 rb_warn(
"GDBM#index is deprecated; use GDBM#key");
471 return fgdbm_key(obj, value);
482fgdbm_select(
VALUE obj)
490 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
491 keystr = rb_gdbm_nextkey(dbm, keystr)) {
516 for (i=0; i<
argc; i++) {
524rb_gdbm_modify(
VALUE obj)
545 if (!gdbm_exists(dbm,
key)) {
549 if (gdbm_delete(dbm,
key)) {
551 rb_raise(rb_eGDBMError,
"%s", gdbm_strerror(gdbm_errno));
571 valstr = fgdbm_fetch(obj, keystr,
Qnil);
572 rb_gdbm_delete(obj, keystr);
584fgdbm_shift(
VALUE obj)
588 VALUE keystr, valstr;
592 keystr = rb_gdbm_firstkey(dbm);
594 valstr = rb_gdbm_fetch2(dbm, keystr);
595 rb_gdbm_delete(obj, keystr);
608fgdbm_delete_if(
VALUE obj)
612 VALUE keystr, valstr;
622 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
623 keystr = rb_gdbm_nextkey(dbm, keystr)) {
626 valstr = rb_gdbm_fetch2(dbm, keystr);
628 if (status != 0)
break;
649fgdbm_clear(
VALUE obj)
660 while (
key = gdbm_firstkey(dbm),
key.dptr) {
661 if (gdbm_delete(dbm,
key)) {
663 rb_raise(rb_eGDBMError,
"%s", gdbm_strerror(gdbm_errno));
668 while (
key = gdbm_firstkey(dbm),
key.dptr) {
669 for (;
key.dptr;
key = nextkey) {
670 nextkey = gdbm_nextkey(dbm,
key);
671 if (gdbm_delete(dbm,
key)) {
673 if (nextkey.dptr)
free(nextkey.dptr);
674 rb_raise(rb_eGDBMError,
"%s", gdbm_strerror(gdbm_errno));
693fgdbm_invert(
VALUE obj)
697 VALUE keystr, valstr;
701 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
702 keystr = rb_gdbm_nextkey(dbm, keystr)) {
703 valstr = rb_gdbm_fetch2(dbm, keystr);
729 key.dsize = RSTRING_LENINT(keystr);
732 val.dsize = RSTRING_LENINT(valstr);
736 if (gdbm_store(dbm,
key, val, GDBM_REPLACE)) {
738 rb_raise(rb_eGDBMError,
"%s", gdbm_strerror(gdbm_errno));
753 fgdbm_store(dbm,
ptr[0],
ptr[1]);
795fgdbm_length(
VALUE obj)
805 for (
key = gdbm_firstkey(dbm);
key.dptr;
key = nextkey) {
806 nextkey = gdbm_nextkey(dbm,
key);
822fgdbm_empty_p(
VALUE obj)
832 key = gdbm_firstkey(dbm);
852fgdbm_each_value(
VALUE obj)
861 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
862 keystr = rb_gdbm_nextkey(dbm, keystr)) {
864 rb_yield(rb_gdbm_fetch2(dbm, keystr));
878fgdbm_each_key(
VALUE obj)
887 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
888 keystr = rb_gdbm_nextkey(dbm, keystr)) {
904fgdbm_each_pair(
VALUE obj)
913 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
914 keystr = rb_gdbm_nextkey(dbm, keystr)) {
938 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
939 keystr = rb_gdbm_nextkey(dbm, keystr)) {
954fgdbm_values(
VALUE obj)
963 for (
key = gdbm_firstkey(dbm);
key.dptr;
key = nextkey) {
964 nextkey = gdbm_nextkey(dbm,
key);
965 valstr = rb_gdbm_fetch(dbm,
key);
992 len = RSTRING_LENINT(keystr);
998 if (gdbm_exists(dbm,
key))
1016 VALUE keystr, valstr2;
1020 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
1021 keystr = rb_gdbm_nextkey(dbm, keystr)) {
1023 valstr2 = rb_gdbm_fetch2(dbm, keystr);
1025 if (!
NIL_P(valstr2) &&
1042fgdbm_to_a(
VALUE obj)
1050 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
1051 keystr = rb_gdbm_nextkey(dbm, keystr)) {
1068fgdbm_reorganize(
VALUE obj)
1073 rb_gdbm_modify(obj);
1075 gdbm_reorganize(dbm);
1091fgdbm_sync(
VALUE obj)
1096 rb_gdbm_modify(obj);
1117 if (gdbm_setopt(dbm, GDBM_CACHESIZE, &optval,
sizeof(optval)) == -1) {
1118 rb_raise(rb_eGDBMError,
"%s", gdbm_strerror(gdbm_errno));
1145 if (gdbm_setopt(dbm, GDBM_FASTMODE, &optval,
sizeof(optval)) == -1) {
1146 rb_raise(rb_eGDBMError,
"%s", gdbm_strerror(gdbm_errno));
1167#if !defined(GDBM_SYNCMODE)
1180 if (gdbm_setopt(dbm, GDBM_FASTMODE, &optval,
sizeof(optval)) == -1) {
1181 rb_raise(rb_eGDBMError,
"%s", gdbm_strerror(gdbm_errno));
1194fgdbm_to_hash(
VALUE obj)
1202 for (keystr = rb_gdbm_firstkey(dbm);
RTEST(keystr);
1203 keystr = rb_gdbm_nextkey(dbm, keystr)) {
1205 rb_hash_aset(hash, keystr, rb_gdbm_fetch2(dbm, keystr));
1219fgdbm_reject(
VALUE obj)
1296#if defined(GDBM_SYNC)
1300#if defined(GDBM_NOLOCK)
VALUE rb_ary_push(VALUE ary, VALUE item)
VALUE rb_ary_tmp_new(long capa)
VALUE rb_ary_clear(VALUE ary)
VALUE rb_assoc_new(VALUE car, VALUE cdr)
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
char str[HTML_ESCAPE_MAX_LEN+1]
#define RSTRING_LEN(string)
#define RSTRING_PTR(string)
#define GetDBM2(obj, dbmp, dbm)
#define GetDBM(obj, dbmp)
void rb_include_module(VALUE klass, VALUE module)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
int rb_block_given_p(void)
Determines if the current method is given a block.
void rb_raise(VALUE exc, const char *fmt,...)
void rb_error_frozen(const char *what)
void rb_sys_fail_str(VALUE mesg)
VALUE rb_protect(VALUE(*proc)(VALUE), VALUE data, int *pstate)
Protects a function call from potential global escapes from the function.
void rb_warn(const char *fmt,...)
VALUE rb_ensure(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*e_proc)(VALUE), VALUE data2)
An equivalent to ensure clause.
void rb_jump_tag(int tag)
Continues the exception caught by rb_protect() and rb_eval_string_protect().
void rb_sys_fail(const char *mesg)
VALUE rb_cObject
Object class.
VALUE rb_hash_delete_if(VALUE hash)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
#define RETURN_ENUMERATOR(obj, argc, argv)
void rb_fd_fix_cloexec(int fd)
#define rb_str_new(str, len)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
ID rb_intern(const char *)
void rb_define_const(VALUE, const char *, VALUE)
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
int memcmp(const void *s1, const void *s2, size_t len)
VALUE rb_block_call(VALUE q, ID w, int e, const VALUE *r, type *t, VALUE y)
Call a method with a block.
#define RARRAY_CONST_PTR(s)
#define RARRAY_AREF(a, i)
#define ExportStringValue(v)
#define TypedData_Get_Struct(obj, type, data_type, sval)
@ RUBY_TYPED_FREE_IMMEDIATELY
#define TypedData_Make_Struct(klass, type, data_type, sval)