pike.git / src / modules / Gdbm / gdbmmod.c

version» Context lines:

pike.git/src/modules/Gdbm/gdbmmod.c:1:   /*\   ||| This file a part of Pike, and is copyright by Fredrik Hubinette   ||| Pike is distributed as GPL (General Public License)   ||| See the files COPYING and DISCLAIMER for more information.   \*/   #include "global.h" - RCSID("$Id: gdbmmod.c,v 1.14 2001/01/23 22:12:39 grubba Exp $"); + RCSID("$Id: gdbmmod.c,v 1.15 2001/10/26 21:36:04 nilsson Exp $");   #include "gdbm_machine.h"   #include "threads.h"      /* Todo: make sure only one thread accesses the same gdbmmod */      #include "interpret.h"   #include "svalue.h"   #include "stralloc.h"   #include "array.h"   #include "object.h"
pike.git/src/modules/Gdbm/gdbmmod.c:84:    Pike_error("Bad mode flag in gdbm->open.\n");    }    }   }      void gdbmmod_fatal(char *err)   {    Pike_error("GDBM: %s\n",err);   }    + /*! @module Gdbm +  */ +  + /*! @class gdbm +  */ +  + /*! @decl void create(void|string file, void|string mode) +  *! +  *! Without arguments, this function does nothing. With one argument it +  *! opens the given file as a gdbm database, if this fails for some +  *! reason, an error will be generated. If a second argument is present, +  *! it specifies how to open the database using one or more of the follow +  *! flags in a string: +  *! +  *! @string +  *! @value r +  *! Open database for reading +  *! @value w +  *! Open database for writing +  *! @value c +  *! Create database if it does not exist +  *! @value t +  *! Overwrite existing database +  *! @value f +  *! Fast mode +  *! @endstring +  *! +  *! The fast mode prevents the database from syncronizing each change +  *! in the database immediately. This is dangerous because the database +  *! can be left in an unusable state if Pike is terminated abnormally. +  *! +  *! The default mode is @tt{"rwc"@}. +  *! +  *! @note +  *! The gdbm manual states that it is important that the database is +  *! closed properly. Unfortunately this will not be the case if Pike +  *! calls exit() or returns from main(). You should therefore make sure +  *! you call close or destruct your gdbm objects when exiting your +  *! program. This will probably be done automatically in the future. +  */ +    static void gdbmmod_create(INT32 args)   {    struct gdbm_glue *this=THIS;    do_free();    if(args)    {    GDBM_FILE tmp;    struct pike_string *tmp2;    int rwmode = GDBM_WRCREAT;   
pike.git/src/modules/Gdbm/gdbmmod.c:129:       pop_n_elems(args);    if(!THIS->dbf)    Pike_error("Failed to open GDBM database.\n");    }   }      #define STRING_TO_DATUM(dat, st) dat.dptr=st->str,dat.dsize=st->len;   #define DATUM_TO_STRING(dat) make_shared_binary_string(dat.dptr, dat.dsize)    + /*! @decl string fetch(string key) +  *! @decl string `[](string key) +  *! +  *! Return the data associated with the key 'key' in the database. +  *! If there was no such key in the database, zero is returned. +  */ +    static void gdbmmod_fetch(INT32 args)   {    struct gdbm_glue *this=THIS;    datum key,ret;       if(!args)    Pike_error("Too few arguments to gdbm->fetch()\n");       if(sp[-args].type != T_STRING)    Pike_error("Bad argument 1 to gdbm->fetch()\n");
pike.git/src/modules/Gdbm/gdbmmod.c:161:    pop_n_elems(args);    if(ret.dptr)    {    push_string(DATUM_TO_STRING(ret));    free(ret.dptr);    }else{    push_int(0);    }   }    + /*! @decl int delete(string key) +  *! +  *! Remove a key from the database. Note that no error will be generated +  *! if the key does not exist. +  */ +    static void gdbmmod_delete(INT32 args)   {    struct gdbm_glue *this=THIS;    datum key;    int ret;    if(!args)    Pike_error("Too few arguments to gdbm->delete()\n");       if(sp[-args].type != T_STRING)    Pike_error("Bad argument 1 to gdbm->delete()\n");
pike.git/src/modules/Gdbm/gdbmmod.c:187:    THREADS_ALLOW();    mt_lock(& gdbm_lock);    ret=gdbm_delete(this->dbf, key);    mt_unlock(& gdbm_lock);    THREADS_DISALLOW();       pop_n_elems(args);    push_int(0);   }    + /*! @decl string firstkey() +  *! +  *! Return the first key in the database, this can be any key in the +  *! database. +  */ +    static void gdbmmod_firstkey(INT32 args)   {    struct gdbm_glue *this=THIS;    datum ret;    pop_n_elems(args);       if(!this->dbf) Pike_error("GDBM database not open.\n");       THREADS_ALLOW();    mt_lock(& gdbm_lock);
pike.git/src/modules/Gdbm/gdbmmod.c:210:       if(ret.dptr)    {    push_string(DATUM_TO_STRING(ret));    free(ret.dptr);    }else{    push_int(0);    }   }    + /*! @decl string nextkey(string key) +  *! +  *! This returns the key in database that follows the key 'key' key. +  *! This is of course used to iterate over all keys in the database. +  *! +  *! @example +  *! // Write the contents of the database +  *! for(key=gdbm->firstkey(); k; k=gdbm->nextkey(k)) +  *! write(k+":"+gdbm->fetch(k)+"\n"); +  */ +    static void gdbmmod_nextkey(INT32 args)   {    struct gdbm_glue *this=THIS;    datum key,ret;    if(!args)    Pike_error("Too few arguments to gdbm->nextkey()\n");       if(sp[-args].type != T_STRING)    Pike_error("Bad argument 1 to gdbm->nextkey()\n");   
pike.git/src/modules/Gdbm/gdbmmod.c:241:    pop_n_elems(args);    if(ret.dptr)    {    push_string(DATUM_TO_STRING(ret));    free(ret.dptr);    }else{    push_int(0);    }   }    + /*! @decl int store(string key, string data) +  *! @decl int `[]= (string key, stirng data) +  *! +  *! Associate the contents of 'data' with the key 'key'. If the key 'key' +  *! already exists in the database the data for that key will be replaced. +  *! If it does not exist it will be added. An error will be generated if +  *! the database was not open for writing. +  *! +  *! @example +  *! gdbm[key] = data; +  */ +    static void gdbmmod_store(INT32 args)   {    struct gdbm_glue *this=THIS;    datum key,data;    int method = GDBM_REPLACE;    int ret;    if(args<2)    Pike_error("Too few arguments to gdbm->store()\n");       if(sp[-args].type != T_STRING)
pike.git/src/modules/Gdbm/gdbmmod.c:286:       if(ret == -1) {    Pike_error("GDBM database not open for writing.\n");    } else if (ret == 1) {    Pike_error("Duplicate key.\n");    }    pop_n_elems(args);    push_int(ret == 0);   }    + /*! @decl int reorganize() +  *! +  *! Deletions and insertions into the database can cause fragmentation +  *! which will make the database bigger. This routine reorganizes the +  *! contents to get rid of fragmentation. Note however that this function +  *! can take a LOT of time to run. +  */ +    static void gdbmmod_reorganize(INT32 args)   {    struct gdbm_glue *this=THIS;    int ret;    pop_n_elems(args);       if(!THIS->dbf) Pike_error("GDBM database not open.\n");    THREADS_ALLOW();    mt_lock(& gdbm_lock);    ret=gdbm_reorganize(this->dbf);    mt_unlock(& gdbm_lock);    THREADS_DISALLOW();    pop_n_elems(args);    push_int(ret);   }    -  + /*! @decl void sync() +  *! +  *! When opening the database with the 'f' flag writings to the database +  *! can be cached in memory for a long time. Calling sync will write +  *! all such caches to disk and not return until everything is stored +  *! on the disk. +  */ +    static void gdbmmod_sync(INT32 args)   {    struct gdbm_glue *this=THIS;    pop_n_elems(args);       if(!THIS->dbf) Pike_error("GDBM database not open.\n");    THREADS_ALLOW();    mt_lock(& gdbm_lock);    gdbm_sync(this->dbf);    mt_unlock(& gdbm_lock);    THREADS_DISALLOW();    push_int(0);   }    -  + /*! @decl void close() +  *! +  *! Closes the database. +  */ +    static void gdbmmod_close(INT32 args)   {    pop_n_elems(args);       do_free();    push_int(0);   }      static void init_gdbm_glue(struct object *o)   {    THIS->dbf=0;   }      static void exit_gdbm_glue(struct object *o)   {    do_free();   }    - #endif + /*! @endclass +  */    -  + /*! @endmodule +  */ +  + #endif /* defined(HAVE_GDBM_H) && defined(HAVE_LIBGDBM) */ +    void pike_module_exit(void) {}      void pike_module_init(void)   {   #if defined(HAVE_GDBM_H) && defined(HAVE_LIBGDBM)    start_new_program();    ADD_STORAGE(struct gdbm_glue);       /* function(void|string,void|string:void) */    ADD_FUNCTION("create", gdbmmod_create,
pike.git/src/modules/Gdbm/gdbmmod.c:376: Inside #if defined(HAVE_GDBM_H) && defined(HAVE_LIBGDBM)
   /* function(:int) */    ADD_FUNCTION("reorganize",gdbmmod_reorganize,tFunc(tNone,tInt),0);    /* function(:void) */    ADD_FUNCTION("sync",gdbmmod_sync,tFunc(tNone,tVoid),0);       set_init_callback(init_gdbm_glue);    set_exit_callback(exit_gdbm_glue);    end_class("gdbm",0);   #endif   } -  +