cdb-full 0.5a

data/cdb-0.75/scan.h

@@ -0,0 +1,28 @@
+#ifndef SCAN_H
+#define SCAN_H
+
+extern unsigned int scan_uint(char *,unsigned int *);
+extern unsigned int scan_xint(char *,unsigned int *);
+extern unsigned int scan_nbbint(char *,unsigned int,unsigned int,unsigned int,unsigned int *);
+extern unsigned int scan_ushort(char *,unsigned short *);
+extern unsigned int scan_xshort(char *,unsigned short *);
+extern unsigned int scan_nbbshort(char *,unsigned int,unsigned int,unsigned int,unsigned short *);
+extern unsigned int scan_ulong(char *,unsigned long *);
+extern unsigned int scan_xlong(char *,unsigned long *);
+extern unsigned int scan_nbblong(char *,unsigned int,unsigned int,unsigned int,unsigned long *);
+
+extern unsigned int scan_plusminus(char *,int *);
+extern unsigned int scan_0x(char *,unsigned int *);
+
+extern unsigned int scan_whitenskip(char *,unsigned int);
+extern unsigned int scan_nonwhitenskip(char *,unsigned int);
+extern unsigned int scan_charsetnskip(char *,char *,unsigned int);
+extern unsigned int scan_noncharsetnskip(char *,char *,unsigned int);
+
+extern unsigned int scan_strncmp(char *,char *,unsigned int);
+extern unsigned int scan_memcmp(char *,char *,unsigned int);
+
+extern unsigned int scan_long(char *,long *);
+extern unsigned int scan_8long(char *,unsigned long *);
+
+#endif

data/cdb-0.75/scan_ulong.c

@@ -0,0 +1,11 @@
+#include "scan.h"
+
+unsigned int scan_ulong(register char *s,register unsigned long *u)
+{
+  register unsigned int pos; register unsigned long result;
+  register unsigned long c;
+  pos = 0; result = 0;
+  while ((c = (unsigned long) (unsigned char) (s[pos] - '0')) < 10)
+    { result = result * 10 + c; ++pos; }
+  *u = result; return pos;
+}

data/cdb-0.75/seek.h

@@ -0,0 +1,15 @@
+#ifndef SEEK_H
+#define SEEK_H
+
+typedef unsigned long seek_pos;
+
+extern seek_pos seek_cur(int);
+
+extern int seek_set(int,seek_pos);
+extern int seek_end(int);
+
+extern int seek_trunc(int,seek_pos);
+
+#define seek_begin(fd) (seek_set((fd),(seek_pos) 0))
+
+#endif

data/cdb-0.75/seek_cur.c

@@ -0,0 +1,7 @@
+#include <sys/types.h>
+#include "seek.h"
+
+#define CUR 1 /* sigh */
+
+seek_pos seek_cur(int fd)
+{ return lseek(fd,(off_t) 0,CUR); }

data/cdb-0.75/seek_set.c

@@ -0,0 +1,7 @@
+#include <sys/types.h>
+#include "seek.h"
+
+#define SET 0 /* sigh */
+
+int seek_set(int fd,seek_pos pos)
+{ if (lseek(fd,(off_t) pos,SET) == -1) return -1; return 0; }

data/cdb-0.75/str.h

@@ -0,0 +1,14 @@
+#ifndef STR_H
+#define STR_H
+
+extern unsigned int str_copy(char *,char *);
+extern int str_diff(char *,char *);
+extern int str_diffn(char *,char *,unsigned int);
+extern unsigned int str_len(char *);
+extern unsigned int str_chr(char *,int);
+extern unsigned int str_rchr(char *,int);
+extern int str_start(char *,char *);
+
+#define str_equal(s,t) (!str_diff((s),(t)))
+
+#endif

data/cdb-0.75/str_len.c

@@ -0,0 +1,14 @@
+#include "str.h"
+
+unsigned int str_len(char *s)
+{
+  register char *t;
+
+  t = s;
+  for (;;) {
+    if (!*t) return t - s; ++t;
+    if (!*t) return t - s; ++t;
+    if (!*t) return t - s; ++t;
+    if (!*t) return t - s; ++t;
+  }
+}

data/cdb-0.75/strerr.h

@@ -0,0 +1,78 @@
+#ifndef STRERR_H
+#define STRERR_H
+
+struct strerr {
+  struct strerr *who;
+  char *x;
+  char *y;
+  char *z;
+} ;
+
+extern struct strerr strerr_sys;
+extern void strerr_sysinit(void);
+
+extern char *strerr(struct strerr *);
+extern void strerr_warn(char *,char *,char *,char *,char *,char *,struct strerr *);
+extern void strerr_die(int,char *,char *,char *,char *,char *,char *,struct strerr *);
+
+#define STRERR(r,se,a) \
+{ se.who = 0; se.x = a; se.y = 0; se.z = 0; return r; }
+
+#define STRERR_SYS(r,se,a) \
+{ se.who = &strerr_sys; se.x = a; se.y = 0; se.z = 0; return r; }
+#define STRERR_SYS3(r,se,a,b,c) \
+{ se.who = &strerr_sys; se.x = a; se.y = b; se.z = c; return r; }
+
+#define strerr_warn6(x1,x2,x3,x4,x5,x6,se) \
+strerr_warn((x1),(x2),(x3),(x4),(x5),(x6),(se))
+#define strerr_warn5(x1,x2,x3,x4,x5,se) \
+strerr_warn((x1),(x2),(x3),(x4),(x5),0,(se))
+#define strerr_warn4(x1,x2,x3,x4,se) \
+strerr_warn((x1),(x2),(x3),(x4),0,0,(se))
+#define strerr_warn3(x1,x2,x3,se) \
+strerr_warn((x1),(x2),(x3),0,0,0,(se))
+#define strerr_warn2(x1,x2,se) \
+strerr_warn((x1),(x2),0,0,0,0,(se))
+#define strerr_warn1(x1,se) \
+strerr_warn((x1),0,0,0,0,0,(se))
+
+#define strerr_die6(e,x1,x2,x3,x4,x5,x6,se) \
+strerr_die((e),(x1),(x2),(x3),(x4),(x5),(x6),(se))
+#define strerr_die5(e,x1,x2,x3,x4,x5,se) \
+strerr_die((e),(x1),(x2),(x3),(x4),(x5),0,(se))
+#define strerr_die4(e,x1,x2,x3,x4,se) \
+strerr_die((e),(x1),(x2),(x3),(x4),0,0,(se))
+#define strerr_die3(e,x1,x2,x3,se) \
+strerr_die((e),(x1),(x2),(x3),0,0,0,(se))
+#define strerr_die2(e,x1,x2,se) \
+strerr_die((e),(x1),(x2),0,0,0,0,(se))
+#define strerr_die1(e,x1,se) \
+strerr_die((e),(x1),0,0,0,0,0,(se))
+
+#define strerr_die6sys(e,x1,x2,x3,x4,x5,x6) \
+strerr_die((e),(x1),(x2),(x3),(x4),(x5),(x6),&strerr_sys)
+#define strerr_die5sys(e,x1,x2,x3,x4,x5) \
+strerr_die((e),(x1),(x2),(x3),(x4),(x5),0,&strerr_sys)
+#define strerr_die4sys(e,x1,x2,x3,x4) \
+strerr_die((e),(x1),(x2),(x3),(x4),0,0,&strerr_sys)
+#define strerr_die3sys(e,x1,x2,x3) \
+strerr_die((e),(x1),(x2),(x3),0,0,0,&strerr_sys)
+#define strerr_die2sys(e,x1,x2) \
+strerr_die((e),(x1),(x2),0,0,0,0,&strerr_sys)
+#define strerr_die1sys(e,x1) \
+strerr_die((e),(x1),0,0,0,0,0,&strerr_sys)
+
+#define strerr_die6x(e,x1,x2,x3,x4,x5,x6) \
+strerr_die((e),(x1),(x2),(x3),(x4),(x5),(x6),0)
+#define strerr_die5x(e,x1,x2,x3,x4,x5) \
+strerr_die((e),(x1),(x2),(x3),(x4),(x5),0,0)
+#define strerr_die4x(e,x1,x2,x3,x4) \
+strerr_die((e),(x1),(x2),(x3),(x4),0,0,0)
+#define strerr_die3x(e,x1,x2,x3) \
+strerr_die((e),(x1),(x2),(x3),0,0,0,0)
+#define strerr_die2x(e,x1,x2) \
+strerr_die((e),(x1),(x2),0,0,0,0,0)
+#define strerr_die1x(e,x1) \
+strerr_die((e),(x1),0,0,0,0,0,0)
+
+#endif

data/cdb-0.75/strerr_die.c

@@ -0,0 +1,31 @@
+#include "buffer.h"
+#include "exit.h"
+#include "strerr.h"
+
+void strerr_warn(char *x1,char *x2,char *x3,char *x4,char *x5,char *x6,struct strerr *se)
+{
+  strerr_sysinit();
+ 
+  if (x1) buffer_puts(buffer_2,x1);
+  if (x2) buffer_puts(buffer_2,x2);
+  if (x3) buffer_puts(buffer_2,x3);
+  if (x4) buffer_puts(buffer_2,x4);
+  if (x5) buffer_puts(buffer_2,x5);
+  if (x6) buffer_puts(buffer_2,x6);
+ 
+  while(se) {
+    if (se->x) buffer_puts(buffer_2,se->x);
+    if (se->y) buffer_puts(buffer_2,se->y);
+    if (se->z) buffer_puts(buffer_2,se->z);
+    se = se->who;
+  }
+ 
+  buffer_puts(buffer_2,"\n");
+  buffer_flush(buffer_2);
+}
+
+void strerr_die(int e,char *x1,char *x2,char *x3,char *x4,char *x5,char *x6,struct strerr *se)
+{
+  strerr_warn(x1,x2,x3,x4,x5,x6,se);
+  _exit(e);
+}

data/cdb-0.75/strerr_sys.c

@@ -0,0 +1,12 @@
+#include "error.h"
+#include "strerr.h"
+
+struct strerr strerr_sys;
+
+void strerr_sysinit(void)
+{
+  strerr_sys.who = 0;
+  strerr_sys.x = error_str(errno);
+  strerr_sys.y = "";
+  strerr_sys.z = "";
+}

data/cdb-0.75/testzero.c

@@ -0,0 +1,35 @@
+#include "uint32.h"
+#include "scan.h"
+#include "strerr.h"
+#include "cdb_make.h"
+
+#define FATAL "testzero: fatal: "
+
+void die_write(void)
+{
+  strerr_die2sys(111,FATAL,"unable to write: ");
+}
+
+static char key[4];
+static char data[65536];
+struct cdb_make c;
+
+main(int argc,char **argv)
+{
+  int fd;
+  unsigned long loop;
+
+  if (!*argv) _exit(0);
+  if (!*++argv) _exit(0);
+  scan_ulong(*argv,&loop);
+
+  if (cdb_make_start(&c,1) == -1) die_write();
+
+  while (loop) {
+    uint32_pack(key,--loop);
+    if (cdb_make_add(&c,key,4,data,sizeof data) == -1) die_write();
+  }
+
+  if (cdb_make_finish(&c) == -1) die_write();
+  _exit(0);
+}

data/cdb-0.75/trycpp.c

@@ -0,0 +1,7 @@
+main()
+{
+#ifdef NeXT
+  printf("nextstep\n"); exit(0);
+#endif
+  printf("unknown\n"); exit(0);
+}

data/cdb-0.75/tryulong32.c

@@ -0,0 +1,11 @@
+void main()
+{
+  unsigned long u;
+  u = 1;
+  u += u; u += u; u += u; u += u; u += u; u += u; u += u; u += u;
+  u += u; u += u; u += u; u += u; u += u; u += u; u += u; u += u;
+  u += u; u += u; u += u; u += u; u += u; u += u; u += u; u += u;
+  u += u; u += u; u += u; u += u; u += u; u += u; u += u; u += u;
+  if (!u) _exit(0);
+  _exit(1);
+}

data/cdb-0.75/uint32.h1

@@ -0,0 +1,11 @@
+#ifndef UINT32_H
+#define UINT32_H
+
+typedef unsigned int uint32;
+
+extern void uint32_pack(char *,uint32);
+extern void uint32_pack_big(char *,uint32);
+extern void uint32_unpack(char *,uint32 *);
+extern void uint32_unpack_big(char *,uint32 *);
+
+#endif

data/cdb-0.75/uint32.h2

@@ -0,0 +1,11 @@
+#ifndef UINT32_H
+#define UINT32_H
+
+typedef unsigned long uint32;
+
+extern void uint32_pack(char *,uint32);
+extern void uint32_pack_big(char *,uint32);
+extern void uint32_unpack(char *,uint32 *);
+extern void uint32_unpack_big(char *,uint32 *);
+
+#endif

data/cdb-0.75/uint32_pack.c

@@ -0,0 +1,21 @@
+#include "uint32.h"
+
+void uint32_pack(char s[4],uint32 u)
+{
+  s[0] = u & 255;
+  u >>= 8;
+  s[1] = u & 255;
+  u >>= 8;
+  s[2] = u & 255;
+  s[3] = u >> 8;
+}
+
+void uint32_pack_big(char s[4],uint32 u)
+{
+  s[3] = u & 255;
+  u >>= 8;
+  s[2] = u & 255;
+  u >>= 8;
+  s[1] = u & 255;
+  s[0] = u >> 8;
+}

data/cdb-0.75/uint32_unpack.c

@@ -0,0 +1,31 @@
+#include "uint32.h"
+
+void uint32_unpack(char s[4],uint32 *u)
+{
+  uint32 result;
+
+  result = (unsigned char) s[3];
+  result <<= 8;
+  result += (unsigned char) s[2];
+  result <<= 8;
+  result += (unsigned char) s[1];
+  result <<= 8;
+  result += (unsigned char) s[0];
+
+  *u = result;
+}
+
+void uint32_unpack_big(char s[4],uint32 *u)
+{
+  uint32 result;
+
+  result = (unsigned char) s[0];
+  result <<= 8;
+  result += (unsigned char) s[1];
+  result <<= 8;
+  result += (unsigned char) s[2];
+  result <<= 8;
+  result += (unsigned char) s[3];
+
+  *u = result;
+}

data/cdb-0.75/warn-auto.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+# WARNING: This file was auto-generated. Do not edit!

data/cdb-0.75/x86cpuid.c

@@ -0,0 +1,38 @@
+#include <signal.h>
+
+void nope()
+{
+  exit(1);
+}
+
+main()
+{
+  unsigned long x[4];
+  unsigned long y[4];
+  int i;
+  int j;
+  char c;
+
+  signal(SIGILL,nope);
+
+  x[0] = 0;
+  x[1] = 0;
+  x[2] = 0;
+  x[3] = 0;
+
+  asm volatile(".byte 15;.byte 162" : "=a"(x[0]),"=b"(x[1]),"=c"(x[3]),"=d"(x[2]) : "0"(0) );
+  if (!x[0]) return 0;
+  asm volatile(".byte 15;.byte 162" : "=a"(y[0]),"=b"(y[1]),"=c"(y[2]),"=d"(y[3]) : "0"(1) );
+
+  for (i = 1;i < 4;++i)
+    for (j = 0;j < 4;++j) {
+      c = x[i] >> (8 * j);
+      if (c < 32) c = 32;
+      if (c > 126) c = 126;
+      putchar(c);
+    }
+
+  printf("-%08x-%08x\n",y[0],y[3]);
+
+  return 0;
+}

data/cdb.c

@@ -0,0 +1,372 @@
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+#include "ruby.h"
+#include "cdb/alloc.h"
+#include "cdb/uint32.h"
+#include "cdb/cdb.h"
+#include "cdb/cdb_make.h"
+
+#define Get_CDB(obj, var) Data_Get_Struct(obj, struct cdb, var)
+#define Get_CDBMake(obj, var) Data_Get_Struct(obj, struct cdb_make, var)
+
+#define Check_FD(cdb) if (cdb->fd == -1) rb_raise(rb_eCDB_Error, "file already closed")
+
+VALUE rb_eCDB_Error;
+
+
+
+static void
+_xread (fd, buf, len)
+   int fd;
+   char *buf;
+   unsigned int len;
+{
+   int ret;
+   while (len > 0) {
+      do
+         ret = read(fd, buf, len);
+      while ((ret == -1) && (errno == EINTR));
+      if (ret == -1) rb_sys_fail(0);
+      if (ret == 0) rb_raise(rb_eCDB_Error, "data format error");
+      len -= ret;
+      buf += ret;
+   }
+}
+
+
+/*
+ * class CDB
+ */
+
+VALUE rb_cCDB;
+
+static void
+_cdb_free (cdb)
+   struct cdb *cdb;
+{
+   cdb_free(cdb);
+   if (cdb->fd != -1) close(cdb->fd);
+   free(cdb);
+}
+
+
+static VALUE
+rb_cdb_new (klass, file)
+   VALUE klass, file;
+{
+   int fd;
+   VALUE obj;
+   struct cdb *cdb;
+
+   Check_Type(file, T_STRING);
+
+   fd = open(StringValuePtr(file), O_RDONLY, 0);
+   if (fd == -1) rb_sys_fail(0);
+
+   obj = Data_Make_Struct(klass, struct cdb, 0, _cdb_free, cdb);
+   cdb_init(cdb, fd);
+
+   return obj;
+}
+
+
+static VALUE
+rb_cdb_close (obj)
+   VALUE obj;
+{
+   struct cdb *cdb;
+   Get_CDB(obj, cdb);
+   Check_FD(cdb);
+   cdb_free(cdb);
+   close(cdb->fd);
+   cdb->fd = -1;
+   return Qnil;
+}
+
+
+static VALUE
+rb_cdb_open (klass, file)
+   VALUE klass, file;
+{
+   VALUE obj;
+   obj = rb_cdb_new(klass, file);
+   return rb_ensure(rb_yield, obj, rb_cdb_close, obj);
+}
+
+
+static VALUE
+_cdb_read (cdb, pos, len)
+   struct cdb *cdb;
+   uint32 pos;
+   unsigned int len;
+{
+   if (cdb->map) {
+      if ((pos > cdb->size) || (cdb->size - pos < len))
+         rb_raise(rb_eCDB_Error, "data format error");
+      return rb_str_new(cdb->map + pos, len);
+   }
+   else {
+      int ret;
+      VALUE s;
+
+      if (seek_set(cdb->fd, pos) == -1) rb_sys_fail(0);
+      s = rb_str_new(0, len);
+      _xread(cdb->fd, RSTRING_PTR(s), len);
+      return s;
+   }
+}
+
+
+static VALUE
+rb_cdb_read (obj, p, l)
+   VALUE obj, p, l;
+{
+   struct cdb *cdb;
+   uint32 pos = NUM2INT(p);
+   unsigned int len = NUM2INT(l);
+
+   Get_CDB(obj, cdb);
+   Check_FD(cdb);
+   return _cdb_read(cdb, pos, len);
+}
+
+
+static VALUE
+rb_cdb_find (obj, key)
+   VALUE obj, key;
+{
+   struct cdb *cdb;
+   uint32 pos;
+
+   Get_CDB(obj, cdb);
+   Check_FD(cdb);
+   StringValue(key);
+   switch (cdb_find(cdb, RSTRING_PTR(key), RSTRING_LEN(key))) {
+      case 1:
+         return _cdb_read(cdb, cdb_datapos(cdb), cdb_datalen(cdb));
+      case 0:
+         return Qnil;
+      case -1:
+         rb_sys_fail(0);
+      default:
+         rb_raise(rb_eCDB_Error, "cdb_find returned unexpected value");
+   }
+}
+
+
+static void
+_read_uint32 (fd, num)
+   int fd;
+   uint32 *num;
+{
+   char buf[4];
+   _xread(fd, buf, 4);
+   uint32_unpack(buf, num);
+}
+
+
+static VALUE
+rb_cdb_each (argc, argv, obj)
+   int argc;
+   VALUE *argv, obj;
+{
+   int ret;
+   VALUE key;
+   struct cdb *cdb;
+
+   Get_CDB(obj, cdb);
+   Check_FD(cdb);
+
+   if (rb_scan_args(argc, argv, "01", &key) == 1) {
+      StringValue(key);
+      cdb_findstart(cdb);
+
+      while ((ret = cdb_findnext(cdb, RSTRING_PTR(key), RSTRING_LEN(key))) == 1)
+         rb_yield(_cdb_read(cdb, cdb_datapos(cdb), cdb_datalen(cdb)));
+
+      switch (ret) {
+         case 0: return obj; 
+         case -1: rb_sys_fail(0);
+         default: rb_raise(rb_eCDB_Error, "cdb_find returned unexpected value");
+      }
+   }
+   else {
+      int fd;
+      VALUE data;
+      struct stat sb;
+      uint32 eod, klen, dlen, pos;
+
+      fd = cdb->fd;
+      if (fstat(fd, &sb) == -1) rb_sys_fail(0);
+      if (cdb->map) {
+         char *eodp, *p = cdb->map;
+
+         uint32_unpack(p, &eod);
+         if (sb.st_size < eod)
+            rb_raise(rb_eCDB_Error, "data format error");
+         eodp = p + eod;
+         p += 2048;
+
+         while (p < eodp) {
+            uint32_unpack(p, &klen); p += 4;
+            uint32_unpack(p, &dlen); p += 4;
+            rb_yield(rb_assoc_new(rb_str_new(p, klen),
+                                  rb_str_new(p + klen, dlen)));
+            p += klen + dlen;
+         }
+      }
+      else {
+         if (seek_set(fd, 0) == -1) rb_sys_fail(0);
+         _read_uint32(fd, &eod);
+         if (sb.st_size < eod)
+            rb_raise(rb_eCDB_Error, "data format error");
+ 
+         if (seek_set(fd, 2048) == -1) rb_sys_fail(0);
+         pos = 2048;
+
+         while (pos < eod) {
+            _read_uint32(fd, &klen);
+            _read_uint32(fd, &dlen);
+
+            key = rb_str_new(0, klen);
+            data = rb_str_new(0, dlen);
+            _xread(fd, RSTRING_PTR(key), klen);
+            _xread(fd, RSTRING_PTR(data), dlen);
+
+            rb_yield(rb_assoc_new(key, data));
+            pos += 8 + klen + dlen;
+         }
+      }
+      return obj;
+   }
+}
+
+
+
+/*
+ * class CDBMake 
+ */
+
+VALUE rb_cCDBMake;
+
+static void
+_cdbmake_free (cdb)
+   struct cdb_make *cdb;
+{
+   struct cdb_hplist *head, *next;
+   head = cdb->head;
+   while (head) {
+      next = head->next;
+      alloc_free(head);
+      head = next;
+   }
+   if (cdb->split) alloc_free(cdb->split);
+   if (cdb->fd != -1) close(cdb->fd);
+   free(cdb);
+}
+
+
+static VALUE
+rb_cdbmake_new (argc, argv, klass)
+   int argc;
+   VALUE *argv, klass;
+{
+   int fd;
+   mode_t mode = 0644;
+   VALUE obj, arg1, arg2;
+   struct cdb_make *cdb;
+
+   if (rb_scan_args(argc, argv, "11", &arg1, &arg2) == 2)
+      mode = NUM2INT(arg2);
+
+   Check_Type(arg1, T_STRING);
+
+   fd = open(StringValuePtr(arg1), O_WRONLY|O_CREAT|O_TRUNC, mode);
+   if (fd == -1) rb_sys_fail(0);
+
+   obj = Data_Make_Struct(klass, struct cdb_make, 0, _cdbmake_free, cdb);
+   if (cdb_make_start(cdb, fd) == -1) rb_sys_fail(0);
+
+   return obj;
+}
+
+
+static VALUE
+rb_cdbmake_finish (obj)
+   VALUE obj;
+{
+   struct cdb_make *cdb;
+
+   Get_CDBMake(obj, cdb);
+   Check_FD(cdb);
+   if (cdb_make_finish(cdb) == -1) rb_sys_fail(0);
+   if (fsync(cdb->fd) == -1) rb_sys_fail(0);
+   close(cdb->fd);
+   cdb->fd = -1;
+   return Qnil;
+}
+
+
+static VALUE
+rb_cdbmake_open (argc, argv, klass)
+   int argc;
+   VALUE *argv, klass;
+{
+   VALUE obj;
+   obj = rb_cdbmake_new(argc, argv, klass);
+   return rb_ensure(rb_yield, obj, rb_cdbmake_finish, obj);
+}
+
+
+static VALUE
+rb_cdbmake_add (obj, key, data)
+   VALUE obj, key, data;
+{
+   struct cdb_make *cdb;
+   
+   Get_CDBMake(obj, cdb);
+   Check_FD(cdb);
+   StringValue(key);
+   StringValue(data);
+   if (cdb_make_add(cdb, RSTRING_PTR(key), RSTRING_LEN(key),
+                         RSTRING_PTR(data), RSTRING_LEN(data)) == -1) rb_sys_fail(0);
+   return obj;
+}
+
+
+
+/*
+ * Module Initialization
+ */
+ 
+void
+Init_cdb ()
+{
+   rb_cCDB = rb_define_class("CDB", rb_cObject);
+   rb_cCDBMake = rb_define_class("CDBMake", rb_cObject);
+   rb_eCDB_Error = rb_define_class("CDBError", rb_eRuntimeError);
+
+   rb_include_module(rb_cCDB, rb_mEnumerable);
+
+   rb_define_singleton_method(rb_cCDB, "new", rb_cdb_new, 1);
+   rb_define_singleton_method(rb_cCDB, "open", rb_cdb_open, 1);
+
+   rb_define_singleton_method(rb_cCDBMake, "new", rb_cdbmake_new, -1);
+   rb_define_singleton_method(rb_cCDBMake, "open", rb_cdbmake_open, -1);
+
+   rb_define_method(rb_cCDB, "find", rb_cdb_find, 1);
+   rb_define_method(rb_cCDB, "[]", rb_cdb_find, 1);
+   rb_define_method(rb_cCDB, "has", rb_cdb_find, 1);
+   rb_define_method(rb_cCDB, "each", rb_cdb_each, -1);
+   rb_define_method(rb_cCDB, "read", rb_cdb_read, 2);
+   rb_define_method(rb_cCDB, "close", rb_cdb_close, 0);
+
+   rb_define_method(rb_cCDBMake, "add", rb_cdbmake_add, 2);
+   rb_define_method(rb_cCDBMake, "[]=", rb_cdbmake_add, 2);
+   rb_define_method(rb_cCDBMake, "finish", rb_cdbmake_finish, 0);
+}
+
+
+