ruby_odeum 0.2.1

data/ext/odeum_index/depot.h

@@ -0,0 +1,439 @@
+/*************************************************************************************************
+ * The basic API of QDBM
+ *                                                      Copyright (C) 2000-2005 Mikio Hirabayashi
+ * This file is part of QDBM, Quick Database Manager.
+ * QDBM is free software; you can redistribute it and/or modify it under the terms of the GNU
+ * Lesser General Public License as published by the Free Software Foundation; either version
+ * 2.1 of the License or any later version.  QDBM is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+ * details.
+ * You should have received a copy of the GNU Lesser General Public License along with QDBM; if
+ * not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307 USA.
+ *************************************************************************************************/
+
+
+#ifndef _DEPOT_H                         /* duplication check */
+#define _DEPOT_H
+
+#if defined(__cplusplus)                 /* export for C++ */
+extern "C" {
+#endif
+
+
+#include <stdlib.h>
+
+
+
+/*************************************************************************************************
+ * API
+ *************************************************************************************************/
+
+
+typedef struct {                         /* type of structure for a database handle */
+  char *name;                            /* name of the database file */
+  int wmode;                             /* whether writable or not */
+  int inode;                             /* inode of the database file */
+  int mtime;                             /* last modified time of the database */
+  int fd;                                /* file descriptor of the database file */
+  int fsiz;                              /* size of the database file */
+  char *map;                             /* pointer to the mapped memory */
+  int msiz;                              /* size of the mapped memory */
+  int *buckets;                          /* pointer to the bucket array */
+  int bnum;                              /* number of the bucket array */
+  int rnum;                              /* number of records */
+  int fatal;                             /* whether a fatal error occured or not */
+  int ioff;                              /* offset of the iterator */
+  int mroff;                             /* offset of the last moved region */
+  int mrsiz;                             /* size of the last moved region */
+  int align;                             /* basic size of alignment */
+} DEPOT;
+
+enum {                                   /* enumeration for error codes */
+  DP_ENOERR,                             /* no error */
+  DP_EFATAL,                             /* with fatal error */
+  DP_EMODE,                              /* invalid mode */
+  DP_EBROKEN,                            /* broken database file */
+  DP_EKEEP,                              /* existing record */
+  DP_ENOITEM,                            /* no item found */
+  DP_EALLOC,                             /* memory allocation error */
+  DP_EMAP,                               /* memory mapping error */
+  DP_EOPEN,                              /* open error */
+  DP_ECLOSE,                             /* close error */
+  DP_ETRUNC,                             /* trunc error */
+  DP_ESYNC,                              /* sync error */
+  DP_ESTAT,                              /* stat error */
+  DP_ESEEK,                              /* seek error */
+  DP_EREAD,                              /* read error */
+  DP_EWRITE,                             /* write error */
+  DP_ELOCK,                              /* lock error */
+  DP_EUNLINK,                            /* unlink error */
+  DP_EMKDIR,                             /* mkdir error */
+  DP_ERMDIR,                             /* rmdir error */
+  DP_EMISC                               /* miscellaneous error */
+};
+
+enum {                                   /* enumeration for open modes */
+  DP_OREADER = 1 << 0,                   /* open as a reader */
+  DP_OWRITER = 1 << 1,                   /* open as a writer */
+  DP_OCREAT = 1 << 2,                    /* a writer creating */
+  DP_OTRUNC = 1 << 3,                    /* a writer truncating */
+  DP_ONOLCK = 1 << 4,                    /* open without locking */
+  DP_OSPARSE = 1 << 5                    /* create as a sparse file */
+};
+
+enum {                                   /* enumeration for write modes */
+  DP_DOVER,                              /* overwrite an existing value */
+  DP_DKEEP,                              /* keep an existing value */
+  DP_DCAT                                /* concatenate values */
+};
+
+
+/* String containing the version information. */
+extern const char *dpversion;
+
+
+/* Last happened error code. */
+#define dpecode        (*dpecodeptr())
+
+
+/* Get a message string corresponding to an error code.
+   `ecode' specifies an error code.
+   The return value is the message string of the error code. The region of the return value
+   is not writable. */
+const char *dperrmsg(int ecode);
+
+
+/* Get a database handle.
+   `name' specifies the name of a database file.
+   `omode' specifies the connection mode: `DP_OWRITER' as a writer, `DP_OREADER' as a reader.
+   If the mode is `DP_OWRITER', the following may be added by bitwise or: `DP_OCREAT', which
+   means it creates a new database if not exist, `DP_OTRUNC', which means it creates a new
+   database regardless if one exists.  Both of `DP_OREADER' and `DP_OWRITER' can be added to by
+   bitwise or: `DP_ONOLCK', which means it opens a database file without file locking.
+   `DP_OCREAT' can be added to by bitwise or: `DP_OSPARSE', which means it creates a database
+   file as a sparse file.
+   `bnum' specifies the number of elements of the bucket array.  If it is not more than 0,
+   the default value is specified.  The size of a bucket array is determined on creating,
+   and can not be changed except for by optimization of the database.  Suggested size of a
+   bucket array is about from 0.5 to 4 times of the number of all records to store.
+   The return value is the database handle or `NULL' if it is not successful.
+   While connecting as a writer, an exclusive lock is invoked to the database file.
+   While connecting as a reader, a shared lock is invoked to the database file.  The thread
+   blocks until the lock is achieved.  If `DP_ONOLCK' is used, the application is responsible
+   for exclusion control. */
+DEPOT *dpopen(const char *name, int omode, int bnum);
+
+
+/* Close a database handle.
+   `depot' specifies a database handle.
+   If successful, the return value is true, else, it is false.
+   Because the region of a closed handle is released, it becomes impossible to use the handle.
+   Updating a database is assured to be written when the handle is closed.  If a writer opens
+   a database but does not close it appropriately, the database will be broken. */
+int dpclose(DEPOT *depot);
+
+
+/* Store a record.
+   `depot' specifies a database handle connected as a writer.
+   `kbuf' specifies the pointer to the region of a key.
+   `ksiz' specifies the size of the region of the key.  If it is negative, the size is assigned
+   with `strlen(kbuf)'.
+   `vbuf' specifies the pointer to the region of a value.
+   `vsiz' specifies the size of the region of the value.  If it is negative, the size is
+   assigned with `strlen(vbuf)'.
+   `dmode' specifies behavior when the key overlaps, by the following values: `DP_DOVER',
+   which means the specified value overwrites the existing one, `DP_DKEEP', which means the
+   existing value is kept, `DP_DCAT', which means the specified value is concatenated at the
+   end of the existing value.
+   If successful, the return value is true, else, it is false. */
+int dpput(DEPOT *depot, const char *kbuf, int ksiz, const char *vbuf, int vsiz, int dmode);
+
+
+/* Delete a record.
+   `depot' specifies a database handle connected as a writer.
+   `kbuf' specifies the pointer to the region of a key.
+   `ksiz' specifies the size of the region of the key.  If it is negative, the size is assigned
+   with `strlen(kbuf)'.
+   If successful, the return value is true, else, it is false.  False is returned when no
+   record corresponds to the specified key. */
+int dpout(DEPOT *depot, const char *kbuf, int ksiz);
+
+
+/* Retrieve a record.
+   `depot' specifies a database handle.
+   `kbuf' specifies the pointer to the region of a key.
+   `ksiz' specifies the size of the region of the key.  If it is negative, the size is assigned
+   with `strlen(kbuf)'.
+   `start' specifies the offset address of the beginning of the region of the value to be read.
+   `max' specifies the max size to be read.  If it is negative, the size to read is unlimited.
+   `sp' specifies the pointer to a variable to which the size of the region of the return
+   value is assigned.  If it is `NULL', it is not used.
+   If successful, the return value is the pointer to the region of the value of the
+   corresponding record, else, it is `NULL'.  `NULL' is returned when no record corresponds to
+   the specified key or the size of the value of the corresponding record is less than `start'.
+   Because an additional zero code is appended at the end of the region of the return value,
+   the return value can be treated as a character string.  Because the region of the return
+   value is allocated with the `malloc' call, it should be released with the `free' call if it
+   is no longer in use. */
+char *dpget(DEPOT *depot, const char *kbuf, int ksiz, int start, int max, int *sp);
+
+
+/* Retrieve a record and write the value into a buffer.
+   `depot' specifies a database handle.
+   `kbuf' specifies the pointer to the region of a key.
+   `ksiz' specifies the size of the region of the key.  If it is negative, the size is assigned
+   with `strlen(kbuf)'.
+   `start' specifies the offset address of the beginning of the region of the value to be read.
+   `max' specifies the max size to be read.  It shuld be equal to or less than the size of the
+   writing buffer.
+   `vbuf' specifies the pointer to a buffer into which the value of the corresponding record is
+   written.
+   If successful, the return value is the size of the written data, else, it is -1.  -1 is
+   returned when no record corresponds to the specified key or the size of the value of the
+   corresponding record is less than `start'.
+   Note that no additional zero code is appended at the end of the region of the writing buffer. */
+int dpgetwb(DEPOT *depot, const char *kbuf, int ksiz, int start, int max, char *vbuf);
+
+
+/* Get the size of the value of a record.
+   `depot' specifies a database handle.
+   `kbuf' specifies the pointer to the region of a key.
+   `ksiz' specifies the size of the region of the key.  If it is negative, the size is assigned
+   with `strlen(kbuf)'.
+   If successful, the return value is the size of the value of the corresponding record, else,
+   it is -1.
+   Because this function does not read the entity of a record, it is faster than `dpget'. */
+int dpvsiz(DEPOT *depot, const char *kbuf, int ksiz);
+
+
+/* Initialize the iterator of a database handle.
+   `depot' specifies a database handle.
+   If successful, the return value is true, else, it is false.
+   The iterator is used in order to access the key of every record stored in a database. */
+int dpiterinit(DEPOT *depot);
+
+
+/* Get the next key of the iterator.
+   `depot' specifies a database handle.
+   `sp' specifies the pointer to a variable to which the size of the region of the return
+   value is assigned.  If it is `NULL', it is not used.
+   If successful, the return value is the pointer to the region of the next key, else, it is
+   `NULL'.  `NULL' is returned when no record is to be get out of the iterator.
+   Because an additional zero code is appended at the end of the region of the return value,
+   the return value can be treated as a character string.  Because the region of the return
+   value is allocated with the `malloc' call, it should be released with the `free' call if
+   it is no longer in use.  It is possible to access every record by iteration of calling
+   this function.  However, it is not assured if updating the database is occurred while the
+   iteration.  Besides, the order of this traversal access method is arbitrary, so it is not
+   assured that the order of storing matches the one of the traversal access. */
+char *dpiternext(DEPOT *depot, int *sp);
+
+
+/* Set alignment of a database handle.
+   `depot' specifies a database handle connected as a writer.
+   `align' specifies the size of alignment.
+   If successful, the return value is true, else, it is false.
+   If alignment is set to a database, the efficiency of overwriting values are improved.
+   The size of alignment is suggested to be average size of the values of the records to be
+   stored.  If alignment is positive, padding whose size is multiple number of the alignment
+   is placed.  If alignment is negative, as `vsiz' is the size of a value, the size of padding
+   is calculated with `(vsiz / pow(2, abs(align) - 1))'.  Because alignment setting is not
+   saved in a database, you should specify alignment every opening a database. */
+int dpsetalign(DEPOT *depot, int align);
+
+
+/* Synchronize updating contents with the file and the device.
+   `depot' specifies a database handle connected as a writer.
+   If successful, the return value is true, else, it is false.
+   This function is useful when another process uses the connected database file. */
+int dpsync(DEPOT *depot);
+
+
+/* Optimize a database.
+   `depot' specifies a database handle connected as a writer.
+   `bnum' specifies the number of the elements of the bucket array.  If it is not more than 0,
+   the default value is specified.
+   If successful, the return value is true, else, it is false.
+   In an alternating succession of deleting and storing with overwrite or concatenate,
+   dispensable regions accumulate.  This function is useful to do away with them. */
+int dpoptimize(DEPOT *depot, int bnum);
+
+
+/* Get the name of a database.
+   `depot' specifies a database handle.
+   If successful, the return value is the pointer to the region of the name of the database,
+   else, it is `NULL'.
+   Because the region of the return value is allocated with the `malloc' call, it should be
+   released with the `free' call if it is no longer in use. */
+char *dpname(DEPOT *depot);
+
+
+/* Get the size of a database file.
+   `depot' specifies a database handle.
+   If successful, the return value is the size of the database file, else, it is -1. */
+int dpfsiz(DEPOT *depot);
+
+
+/* Get the number of the elements of the bucket array.
+   `depot' specifies a database handle.
+   If successful, the return value is the number of the elements of the bucket array, else, it
+   is -1. */
+int dpbnum(DEPOT *depot);
+
+
+/* Get the number of the used elements of the bucket array.
+   `depot' specifies a database handle.
+   If successful, the return value is the number of the used elements of the bucket array,
+   else, it is -1.
+   This function is inefficient because it accesses all elements of the bucket array. */
+int dpbusenum(DEPOT *depot);
+
+
+/* Get the number of the records stored in a database.
+   `depot' specifies a database handle.
+   If successful, the return value is the number of the records stored in the database, else,
+   it is -1. */
+int dprnum(DEPOT *depot);
+
+
+/* Check whether a database handle is a writer or not.
+   `depot' specifies a database handle.
+   The return value is true if the handle is a writer, false if not. */
+int dpwritable(DEPOT *depot);
+
+
+/* Check whether a database has a fatal error or not.
+   `depot' specifies a database handle.
+   The return value is true if the database has a fatal error, false if not. */
+int dpfatalerror(DEPOT *depot);
+
+
+/* Get the inode number of a database file.
+   `depot' specifies a database handle.
+   The return value is the inode number of the database file. */
+int dpinode(DEPOT *depot);
+
+
+/* Get the last modified time of a database.
+   `depot' specifies a database handle.
+   The return value is the last modified time of the database. */
+int dpmtime(DEPOT *depot);
+
+
+/* Get the file descriptor of a database file.
+   `depot' specifies a database handle.
+   The return value is the file descriptor of the database file.
+   Handling the file descriptor of a database file directly is not suggested. */
+int dpfdesc(DEPOT *depot);
+
+
+/* Remove a database file.
+   `name' specifies the name of a database file.
+   If successful, the return value is true, else, it is false. */
+int dpremove(const char *name);
+
+
+/* Repair a broken database file.
+   `name' specifies the name of a database file.
+   If successful, the return value is true, else, it is false.
+   There is no guarantee that all records in a repaired database file correspond to the original
+   or expected state. */
+int dprepair(const char *name);
+
+
+/* Dump all records as endian independent data.
+   `depot' specifies a database handle.
+   `name' specifies the name of an output file.
+   If successful, the return value is true, else, it is false. */
+int dpexportdb(DEPOT *depot, const char *name);
+
+
+/* Load all records from endian independent data.
+   `depot' specifies a database handle connected as a writer.  The database of the handle must
+   be empty.
+   `name' specifies the name of an input file.
+   If successful, the return value is true, else, it is false. */
+int dpimportdb(DEPOT *depot, const char *name);
+
+
+/* Hash function used inside Depot.
+   `kbuf' specifies the pointer to the region of a key.
+   `ksiz' specifies the size of the region of the key.  If it is negative, the size is assigned
+   with `strlen(kbuf)'.
+   The return value is the hash value of 31 bits length computed from the key.
+   This function is useful when an application calculates the state of the inside bucket array. */
+int dpinnerhash(const char *kbuf, int ksiz);
+
+
+/* Hash function which is independent from the hash functions used inside Depot.
+   `kbuf' specifies the pointer to the region of a key.
+   `ksiz' specifies the size of the region of the key.  If it is negative, the size is assigned
+   with `strlen(kbuf)'.
+   The return value is the hash value of 31 bits length computed from the key.
+   This function is useful when an application uses its own hash algorithm outside Depot. */
+int dpouterhash(const char *kbuf, int ksiz);
+
+
+/* Get a natural prime number not less than a number.
+   `num' specified a natural number.
+   The return value is a natural prime number not less than the specified number.
+   This function is useful when an application determines the size of a bucket array of its
+   own hash algorithm. */
+int dpprimenum(int num);
+
+
+
+/*************************************************************************************************
+ * features for experts
+ *************************************************************************************************/
+
+
+/* Name of the operating system. */
+extern char *dpsysname;
+
+
+/* File descriptor for debugging output. */
+extern int dpdbgfd;
+
+
+/* Set the last happened error code.
+   `ecode' specifies the error code.
+   `line' specifies the number of the line where the error happened. */
+void dpecodeset(int ecode, const char *file, int line);
+
+
+/* Get the pointer of the variable of the last happened error code.
+   The return value is the pointer of the variable. */
+int *dpecodeptr(void);
+
+
+/* Synchronize updating contents on memory.
+   `depot' specifies a database handle connected as a writer.
+   If successful, the return value is true, else, it is false. */
+int dpmemsync(DEPOT *depot);
+
+
+/* Get flags of a database.
+   `depot' specifies a database handle.
+   The return value is the flags of a database. */
+int dpgetflags(DEPOT *depot);
+
+
+/* Set flags of a database.
+   `depot' specifies a database handle connected as a writer.
+   `flags' specifies flags to set.
+   If successful, the return value is true, else, it is false. */
+int dpsetflags(DEPOT *depot, int flags);
+
+
+
+#if defined(__cplusplus)                 /* export for C++ */
+}
+#endif
+
+#endif                                   /* duplication check */
+
+
+/* END OF FILE */

data/ext/odeum_index/extconf.rb

@@ -0,0 +1,10 @@
+require 'mkmf'
+
+dir_config("odeum")
+
+have_library("c", "main")
+have_library("pthread", "main")
+have_library("z", "main")
+have_library("iconv", "main")
+
+create_makefile("odeum_index")

data/ext/odeum_index/myconf.c

@@ -0,0 +1,668 @@
+/*************************************************************************************************
+ * Emulation of system calls
+ *                                                      Copyright (C) 2000-2005 Mikio Hirabayashi
+ * This file is part of QDBM, Quick Database Manager.
+ * QDBM is free software; you can redistribute it and/or modify it under the terms of the GNU
+ * Lesser General Public License as published by the Free Software Foundation; either version
+ * 2.1 of the License or any later version.  QDBM is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+ * details.
+ * You should have received a copy of the GNU Lesser General Public License along with QDBM; if
+ * not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307 USA.
+ *************************************************************************************************/
+
+
+#include "myconf.h"
+
+
+
+/*************************************************************************************************
+ * for POSIX thread
+ *************************************************************************************************/
+
+
+#if defined(MYPTHREAD)
+
+
+#include <pthread.h>
+
+
+#define PTKEYMAX       8
+
+
+static struct { void *ptr; pthread_key_t key; } _qdbm_ptkeys[PTKEYMAX];
+static int _qdbm_ptknum = 0;
+
+
+static void *_qdbm_gettsd(void *ptr, int size, const void *initval);
+
+
+void *_qdbm_settsd(void *ptr, int size, const void *initval){
+  static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+  char *val;
+  if((val = _qdbm_gettsd(ptr, size, initval)) != NULL) return val;
+  if(pthread_mutex_lock(&mutex) != 0) return NULL;
+  if((val = _qdbm_gettsd(ptr, size, initval)) != NULL){
+    pthread_mutex_unlock(&mutex);
+    return val;
+  }
+  if(_qdbm_ptknum >= PTKEYMAX){
+    pthread_mutex_unlock(&mutex);
+    return NULL;
+  }
+  _qdbm_ptkeys[_qdbm_ptknum].ptr = ptr;
+  if(pthread_key_create(&(_qdbm_ptkeys[_qdbm_ptknum].key), free) != 0){
+    pthread_mutex_unlock(&mutex);
+    return NULL;
+  }
+  if(!(val = malloc(size))){
+    pthread_key_delete(_qdbm_ptkeys[_qdbm_ptknum].key);
+    pthread_mutex_unlock(&mutex);
+    return NULL;
+  }
+  memcpy(val, initval, size);
+  if(pthread_setspecific(_qdbm_ptkeys[_qdbm_ptknum].key, val) != 0){
+    free(val);
+    pthread_key_delete(_qdbm_ptkeys[_qdbm_ptknum].key);
+    pthread_mutex_unlock(&mutex);
+    return NULL;
+  }
+  _qdbm_ptknum++;
+  pthread_mutex_unlock(&mutex);
+  return val;
+}
+
+
+static void *_qdbm_gettsd(void *ptr, int size, const void *initval){
+  char *val;
+  int i;
+  for(i = 0; i < _qdbm_ptknum; i++){
+    if(_qdbm_ptkeys[i].ptr == ptr){
+      if(!(val = pthread_getspecific(_qdbm_ptkeys[i].key))){
+        if(!(val = malloc(size))) return NULL;
+        memcpy(val, initval, size);
+        if(pthread_setspecific(_qdbm_ptkeys[i].key, val) != 0){
+          free(val);
+          return NULL;
+        }
+      }
+      return val;
+    }
+  }
+  return NULL;
+}
+
+
+#endif
+
+
+
+/*************************************************************************************************
+ * for systems without mmap
+ *************************************************************************************************/
+
+
+#if defined(_SYS_MSVC_) || defined(_SYS_MINGW_) || \
+  defined(_SYS_FREEBSD_) || defined(_SYS_NETBSD_) || defined(_SYS_OPENBSD_) || \
+  defined(_SYS_RISCOS_) || defined(MYNOMMAP)
+
+
+void *_qdbm_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset){
+  char *buf, *wp;
+  int rv, rlen;
+  if(flags & MAP_FIXED) return MAP_FAILED;
+  if(lseek(fd, SEEK_SET, offset) == -1) return MAP_FAILED;
+  if(!(buf = malloc(sizeof(int) * 3 + length))) return MAP_FAILED;
+  wp = buf;
+  *(int *)wp = fd;
+  wp += sizeof(int);
+  *(int *)wp = offset;
+  wp += sizeof(int);
+  *(int *)wp = prot;
+  wp += sizeof(int);
+  rlen = 0;
+  while((rv = read(fd, wp + rlen, length - rlen)) > 0){
+    rlen += rv;
+  }
+  if(rv == -1 || rlen != length){
+    free(buf);
+    return MAP_FAILED;
+  }
+  return wp;
+}
+
+
+int _qdbm_munmap(void *start, size_t length){
+  char *buf, *rp;
+  int fd, offset, prot, rv, wlen;
+  buf = (char *)start - sizeof(int) * 3;
+  rp = buf;
+  fd = *(int *)rp;
+  rp += sizeof(int);
+  offset = *(int *)rp;
+  rp += sizeof(int);
+  prot = *(int *)rp;
+  rp += sizeof(int);
+  if(prot & PROT_WRITE){
+    if(lseek(fd, offset, SEEK_SET) == -1){
+      free(buf);
+      return -1;
+    }
+    wlen = 0;
+    while(wlen < (int)length){
+      rv = write(fd, rp + wlen, length - wlen);
+      if(rv == -1){
+        if(errno == EINTR) continue;
+        free(buf);
+        return -1;
+      }
+      wlen += rv;
+    }
+  }
+  free(buf);
+  return 0;
+}
+
+
+int _qdbm_msync(const void *start, size_t length, int flags){
+  char *buf, *rp;
+  int fd, offset, prot, rv, wlen;
+  buf = (char *)start - sizeof(int) * 3;
+  rp = buf;
+  fd = *(int *)rp;
+  rp += sizeof(int);
+  offset = *(int *)rp;
+  rp += sizeof(int);
+  prot = *(int *)rp;
+  rp += sizeof(int);
+  if(prot & PROT_WRITE){
+    if(lseek(fd, offset, SEEK_SET) == -1) return -1;
+    wlen = 0;
+    while(wlen < (int)length){
+      rv = write(fd, rp + wlen, length - wlen);
+      if(rv == -1){
+        if(errno == EINTR) continue;
+        return -1;
+      }
+      wlen += rv;
+    }
+  }
+  return 0;
+}
+
+
+#endif
+
+
+
+/*************************************************************************************************
+ * for reentrant time routines
+ *************************************************************************************************/
+
+
+#if defined(_SYS_LINUX_) || defined(_SYS_FREEBSD_) || defined(_SYS_OPENBSD_) || \
+  defined(_SYS_NETBSD_) || defined(_SYS_SUNOS_) || defined(_SYS_HPUX_) || \
+  defined(_SYS_MACOSX_) || defined(_SYS_CYGWIN_)
+
+
+struct tm *_qdbm_gmtime(const time_t *timep, struct tm *result){
+  return gmtime_r(timep, result);
+}
+
+
+struct tm *_qdbm_localtime(const time_t *timep, struct tm *result){
+  return localtime_r(timep, result);
+}
+
+
+# else
+
+
+struct tm *_qdbm_gmtime(const time_t *timep, struct tm *result){
+  return gmtime(timep);
+}
+
+
+struct tm *_qdbm_localtime(const time_t *timep, struct tm *result){
+  return localtime(timep);
+}
+
+
+# endif
+
+
+
+/*************************************************************************************************
+ * for systems without times
+ *************************************************************************************************/
+
+
+#if defined(_SYS_MSVC_) || defined(_SYS_MINGW_)
+
+
+clock_t _qdbm_times(struct tms *buf){
+  buf->tms_utime = clock();
+  buf->tms_stime = 0;
+  buf->tms_cutime = 0;
+  buf->tms_cstime = 0;
+  return 0;
+}
+
+
+#endif
+
+
+
+/*************************************************************************************************
+ * for Win32
+ *************************************************************************************************/
+
+
+#if defined(_SYS_MSVC_) || defined(_SYS_MINGW_)
+
+
+#define WINLOCKWAIT    100
+
+
+int _qdbm_win32_fcntl(int fd, int cmd, struct flock *lock){
+  HANDLE fh;
+  OVERLAPPED ol;
+  fh = (HANDLE)_get_osfhandle(fd);
+  memset(&ol, 0, sizeof(OVERLAPPED));
+  ol.Offset = 0;
+  ol.OffsetHigh = 0;
+  ol.hEvent = 0;
+  if(!LockFileEx(fh, lock->l_type == F_WRLCK ? LOCKFILE_EXCLUSIVE_LOCK : 0, 0, 1, 0, &ol)){
+    if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED){
+      while(TRUE){
+        if(LockFile(fh, 0, 0, 1, 0)) return 0;
+        Sleep(WINLOCKWAIT);
+      }
+    }
+    return -1;
+  }
+  return 0;
+}
+
+
+#endif
+
+
+#if defined(_SYS_MSVC_)
+
+
+DIR *_qdbm_win32_opendir(const char *name){
+  char expr[1024];
+  DIR *dir;
+  HANDLE fh;
+  WIN32_FIND_DATA data;
+  sprintf(expr, "%s%c*", name, MYPATHCHR);
+  if((fh = FindFirstFile(expr, &data)) == INVALID_HANDLE_VALUE) return NULL;
+  if(!(dir = malloc(sizeof(DIR)))){
+    FindClose(fh);
+    return NULL;
+  }
+  dir->fh = fh;
+  dir->data = data;
+  dir->first = TRUE;
+  return dir;
+}
+
+
+int _qdbm_win32_closedir(DIR *dir){
+  if(!FindClose(dir->fh)){
+    free(dir);
+    return -1;
+  }
+  free(dir);
+  return 0;
+}
+
+
+struct dirent *_qdbm_win32_readdir(DIR *dir){
+  if(dir->first){
+    sprintf(dir->de.d_name, "%s", dir->data.cFileName);
+    dir->first = FALSE;
+    return &(dir->de);
+  }
+  if(!FindNextFile(dir->fh, &(dir->data))) return NULL;
+  sprintf(dir->de.d_name, "%s", dir->data.cFileName);
+  return &(dir->de);
+}
+
+
+#endif
+
+
+
+/*************************************************************************************************
+ * for ZLIB
+ *************************************************************************************************/
+
+
+#if defined(MYZLIB)
+
+
+#include <zlib.h>
+
+#define ZLIBBUFSIZ     8192
+#define ZLIBCLEVEL     5
+
+
+static char *_qdbm_deflate_impl(const char *ptr, int size, int *sp);
+static char *_qdbm_inflate_impl(const char *ptr, int size, int *sp);
+static unsigned int _qdbm_getcrc_impl(const char *ptr, int size);
+
+
+char *(*_qdbm_deflate)(const char *, int, int *) = _qdbm_deflate_impl;
+char *(*_qdbm_inflate)(const char *, int, int *) = _qdbm_inflate_impl;
+unsigned int (*_qdbm_getcrc)(const char *, int) = _qdbm_getcrc_impl;
+
+
+static char *_qdbm_deflate_impl(const char *ptr, int size, int *sp){
+  z_stream zs;
+  char *buf, *swap;
+  unsigned char obuf[ZLIBBUFSIZ];
+  int rv, asiz, bsiz, osiz;
+  if(size < 0) size = strlen(ptr);
+  zs.zalloc = Z_NULL;
+  zs.zfree = Z_NULL;
+  zs.opaque = Z_NULL;
+  if(deflateInit(&zs, ZLIBCLEVEL) != Z_OK) return NULL;
+  asiz = ZLIBBUFSIZ;
+  if(!(buf = malloc(asiz))){
+    deflateEnd(&zs);
+    return NULL;
+  }
+  bsiz = 0;
+  zs.next_in = (unsigned char *)ptr;
+  zs.avail_in = size;
+  zs.next_out = obuf;
+  zs.avail_out = ZLIBBUFSIZ;
+  while((rv = deflate(&zs, Z_FINISH)) == Z_OK){
+    osiz = ZLIBBUFSIZ - zs.avail_out;
+    if(bsiz + osiz > asiz){
+      asiz = asiz * 2 + osiz;
+      if(!(swap = realloc(buf, asiz))){
+        free(buf);
+        deflateEnd(&zs);
+        return NULL;
+      }
+      buf = swap;
+    }
+    memcpy(buf + bsiz, obuf, osiz);
+    bsiz += osiz;
+    zs.next_out = obuf;
+    zs.avail_out = ZLIBBUFSIZ;
+  }
+  if(rv != Z_STREAM_END){
+    free(buf);
+    deflateEnd(&zs);
+    return NULL;
+  }
+  osiz = ZLIBBUFSIZ - zs.avail_out;
+  if(bsiz + osiz > asiz){
+    asiz = asiz * 2 + osiz;
+    if(!(swap = realloc(buf, asiz))){
+      free(buf);
+      deflateEnd(&zs);
+      return NULL;
+    }
+    buf = swap;
+  }
+  memcpy(buf + bsiz, obuf, osiz);
+  bsiz += osiz;
+  *sp = bsiz;
+  deflateEnd(&zs);
+  return buf;
+}
+
+
+static char *_qdbm_inflate_impl(const char *ptr, int size, int *sp){
+  z_stream zs;
+  char *buf, *swap;
+  unsigned char obuf[ZLIBBUFSIZ];
+  int rv, asiz, bsiz, osiz;
+  zs.zalloc = Z_NULL;
+  zs.zfree = Z_NULL;
+  zs.opaque = Z_NULL;
+  if(inflateInit(&zs) != Z_OK) return NULL;
+  asiz = ZLIBBUFSIZ;
+  if(!(buf = malloc(asiz))){
+    deflateEnd(&zs);
+    return NULL;
+  }
+  bsiz = 0;
+  zs.next_in = (unsigned char *)ptr;
+  zs.avail_in = size;
+  zs.next_out = obuf;
+  zs.avail_out = ZLIBBUFSIZ;
+  while((rv = inflate(&zs, Z_NO_FLUSH)) == Z_OK){
+    osiz = ZLIBBUFSIZ - zs.avail_out;
+    if(bsiz + osiz >= asiz){
+      asiz = asiz * 2 + osiz;
+      if(!(swap = realloc(buf, asiz))){
+        free(buf);
+        deflateEnd(&zs);
+        return NULL;
+      }
+      buf = swap;
+    }
+    memcpy(buf + bsiz, obuf, osiz);
+    bsiz += osiz;
+    zs.next_out = obuf;
+    zs.avail_out = ZLIBBUFSIZ;
+  }
+  if(rv != Z_STREAM_END){
+    free(buf);
+    inflateEnd(&zs);
+    return NULL;
+  }
+  osiz = ZLIBBUFSIZ - zs.avail_out;
+  if(bsiz + osiz >= asiz){
+    asiz = asiz * 2 + osiz;
+    if(!(swap = realloc(buf, asiz))){
+      free(buf);
+      deflateEnd(&zs);
+      return NULL;
+    }
+    buf = swap;
+  }
+  memcpy(buf + bsiz, obuf, osiz);
+  bsiz += osiz;
+  buf[bsiz] = '\0';
+  if(sp) *sp = bsiz;
+  inflateEnd(&zs);
+  return buf;
+}
+
+
+static unsigned int _qdbm_getcrc_impl(const char *ptr, int size){
+  int crc;
+  if(size < 0) size = strlen(ptr);
+  crc = crc32(0, Z_NULL, 0);
+  return crc32(crc, (unsigned char *)ptr, size);
+}
+
+
+#else
+
+
+char *(*_qdbm_deflate)(const char *, int, int *) = NULL;
+char *(*_qdbm_inflate)(const char *, int, int *) = NULL;
+unsigned int (*_qdbm_getcrc)(const char *, int) = NULL;
+
+
+#endif
+
+
+
+/*************************************************************************************************
+ * for ICONV
+ *************************************************************************************************/
+
+
+#if defined(MYICONV)
+
+
+#include <iconv.h>
+
+#define ICONVCHECKSIZ  32768
+#define ICONVMISSMAX   256
+#define ICONVALLWRAT   0.001
+
+
+static char *_qdbm_iconv_impl(const char *ptr, int size,
+                              const char *icode, const char *ocode, int *sp, int *mp);
+static const char *_qdbm_encname_impl(const char *ptr, int size);
+static int _qdbm_encmiss(const char *ptr, int size, const char *icode, const char *ocode);
+
+
+char *(*_qdbm_iconv)(const char *, int, const char *, const char *,
+                     int *, int *) = _qdbm_iconv_impl;
+const char *(*_qdbm_encname)(const char *, int) = _qdbm_encname_impl;
+
+
+static char *_qdbm_iconv_impl(const char *ptr, int size,
+                              const char *icode, const char *ocode, int *sp, int *mp){
+  iconv_t ic;
+  char *obuf, *wp, *rp;
+  size_t isiz, osiz;
+  int miss;
+  if(size < 0) size = strlen(ptr);
+  isiz = size;
+  if((ic = iconv_open(ocode, icode)) == (iconv_t)-1) return NULL;
+  osiz = isiz * 5;
+  if(!(obuf = malloc(osiz + 1))){
+    iconv_close(ic);
+    return NULL;
+  }
+  wp = obuf;
+  rp = (char *)ptr;
+  miss = 0;
+  while(isiz > 0){
+    if(iconv(ic, (void *)&rp, &isiz, &wp, &osiz) == -1){
+      if(errno == EILSEQ && (*rp == 0x5c || *rp == 0x7e)){
+        *wp = *rp;
+        wp++;
+        rp++;
+        isiz--;
+      } else if(errno == EILSEQ || errno == EINVAL){
+        rp++;
+        isiz--;
+        miss++;
+      } else {
+        break;
+      }
+    }
+  }
+  *wp = '\0';
+  if(iconv_close(ic) == -1){
+    free(obuf);
+    return NULL;
+  }
+  if(sp) *sp = wp - obuf;
+  if(mp) *mp = miss;
+  return obuf;
+}
+
+
+static const char *_qdbm_encname_impl(const char *ptr, int size){
+  const char *hypo;
+  int i, miss, cr;
+  if(size < 0) size = strlen(ptr);
+  if(size > ICONVCHECKSIZ) size = ICONVCHECKSIZ;
+  if(size >= 2 && (!memcmp(ptr, "\xfe\xff", 2) || !memcmp(ptr, "\xff\xfe", 2))) return "UTF-16";
+  for(i = 0; i < size - 1; i += 2){
+    if(ptr[i] == 0 && ptr[i+1] != 0) return "UTF-16BE";
+    if(ptr[i+1] == 0 && ptr[i] != 0) return "UTF-16LE";
+  }
+  for(i = 0; i < size - 3; i++){
+    if(ptr[i] == 0x1b){
+      i++;
+      if(ptr[i] == '(' && strchr("BJHI", ptr[i+1])) return "ISO-2022-JP";
+      if(ptr[i] == '$' && strchr("@B(", ptr[i+1])) return "ISO-2022-JP";
+    }
+  }
+  if(_qdbm_encmiss(ptr, size, "US-ASCII", "UTF-16BE") < 1) return "US-ASCII";
+  if(_qdbm_encmiss(ptr, size, "UTF-8", "UTF-16BE") < 1) return "UTF-8";
+  hypo = NULL;
+  cr = FALSE;
+  for(i = 0; i < size; i++){
+    if(ptr[i] == 0xd){
+      cr = TRUE;
+      break;
+    }
+  }
+  if(cr){
+    if((miss = _qdbm_encmiss(ptr, size, "Shift_JIS", "EUC-JP")) < 1) return "Shift_JIS";
+    if(!hypo && miss / (double)size <= ICONVALLWRAT) hypo = "Shift_JIS";
+    if((miss = _qdbm_encmiss(ptr, size, "EUC-JP", "UTF-16BE")) < 1) return "EUC-JP";
+    if(!hypo && miss / (double)size <= ICONVALLWRAT) hypo = "EUC-JP";
+  } else {
+    if((miss = _qdbm_encmiss(ptr, size, "EUC-JP", "UTF-16BE")) < 1) return "EUC-JP";
+    if(!hypo && miss / (double)size <= ICONVALLWRAT) hypo = "EUC-JP";
+    if((miss = _qdbm_encmiss(ptr, size, "Shift_JIS", "EUC-JP")) < 1) return "Shift_JIS";
+    if(!hypo && miss / (double)size <= ICONVALLWRAT) hypo = "Shift_JIS";
+  }
+  if((miss = _qdbm_encmiss(ptr, size, "UTF-8", "UTF-16BE")) < 1) return "UTF-8";
+  if(!hypo && miss / (double)size <= ICONVALLWRAT) hypo = "UTF-8";
+  if((miss = _qdbm_encmiss(ptr, size, "CP932", "UTF-16BE")) < 1) return "CP932";
+  if(!hypo && miss / (double)size <= ICONVALLWRAT) hypo = "CP932";
+  return hypo ? hypo : "ISO-8859-1";
+}
+
+
+static int _qdbm_encmiss(const char *ptr, int size, const char *icode, const char *ocode){
+  iconv_t ic;
+  char obuf[ICONVCHECKSIZ], *wp, *rp;
+  size_t isiz, osiz;
+  int miss;
+  isiz = size;
+  if((ic = iconv_open(ocode, icode)) == (iconv_t)-1) return ICONVMISSMAX;
+  miss = 0;
+  rp = (char *)ptr;
+  while(isiz > 0){
+    osiz = ICONVCHECKSIZ;
+    wp = obuf;
+    if(iconv(ic, (void *)&rp, &isiz, &wp, &osiz) == -1){
+      if(errno == EILSEQ || errno == EINVAL){
+        rp++;
+        isiz--;
+        miss++;
+        if(miss >= ICONVMISSMAX) break;
+      } else {
+        break;
+      }
+    }
+  }
+  if(iconv_close(ic) == -1) return ICONVMISSMAX;
+  return miss;
+}
+
+
+#else
+
+
+char *(*_qdbm_iconv)(const char *, int, const char *, const char *, int *, int *) = NULL;
+const char *(*_qdbm_encname)(const char *, int) = NULL;
+
+
+#endif
+
+
+
+/*************************************************************************************************
+ * common settings
+ *************************************************************************************************/
+
+
+int _qdbm_dummyfunc(void){
+  return 0;
+}
+
+
+
+/* END OF FILE */