gdbm-1.7.2/ 40700 24413 24 0 5565367064 11102 5ustar downsjusergdbm-1.7.2/dbminit.c100600 24413 24 7252 5507304022 12756 0ustar downsjuser/* dbminit.c - Open the file for dbm operations. This looks like the DBM interface. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" #include "extern.h" /* Initialize dbm system. FILE is a pointer to the file name. In standard dbm, the database is found in files called FILE.pag and FILE.dir. To make gdbm compatable with dbm using the dbminit call, the same file names are used. Specifically, dbminit will use the file name FILE.pag in its call to gdbm open. If the file (FILE.pag) has a size of zero bytes, a file initialization procedure is performed, setting up the initial structure in the file. Any error detected will cause a return value of -1. No errors cause the return value of 0. NOTE: file.dir will be linked to file.pag. */ int dbminit (file) char *file; { char* pag_file; /* Used to construct "file.pag". */ char* dir_file; /* Used to construct "file.dir". */ struct stat dir_stat; /* Stat information for "file.dir". */ /* Prepare the correct names of "file.pag" and "file.dir". */ pag_file = (char *) alloca (strlen (file)+5); dir_file = (char *) alloca (strlen (file)+5); strcpy (pag_file, file); strcat (pag_file, ".pag"); strcpy (dir_file, file); strcat (dir_file, ".dir"); if (_gdbm_file != NULL) gdbm_close (_gdbm_file); /* Try to open the file as a writer. DBM never created a file. */ _gdbm_file = gdbm_open (pag_file, 0, GDBM_WRITER, 0, NULL); /* If it was not opened, try opening it as a reader. */ if (_gdbm_file == NULL) { _gdbm_file = gdbm_open (pag_file, 0, GDBM_READER, 0, NULL); /* Did we successfully open the file? */ if (_gdbm_file == NULL) { gdbm_errno = GDBM_FILE_OPEN_ERROR; return -1; } } /* If the database is new, link "file.dir" to "file.pag". This is done so the time stamp on both files is the same. */ if (stat (dir_file, &dir_stat) == 0) { if (dir_stat.st_size == 0) if (unlink (dir_file) != 0 || link (pag_file, dir_file) != 0) { gdbm_errno = GDBM_FILE_OPEN_ERROR; gdbm_close (_gdbm_file); return -1; } } else { /* Since we can't stat it, we assume it is not there and try to link the dir_file to the pag_file. */ if (link (pag_file, dir_file) != 0) { gdbm_errno = GDBM_FILE_OPEN_ERROR; gdbm_close (_gdbm_file); return -1; } } return 0; } gdbm-1.7.2/delete.c100600 24413 24 2760 5507304163 12577 0ustar downsjuser/* delete.c - Remove the key and its associated data from the database. This is the original unix interface name. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "extern.h" /* Remove the KEYed item and the KEY from the database. */ int delete (key) datum key; { return gdbm_delete (_gdbm_file, key); } gdbm-1.7.2/fetch.c100600 24413 24 3756 5507304334 12434 0ustar downsjuser/* fetch.c - Find a key and return the associated data. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "extern.h" /* Look up a given KEY and return the information associated with that KEY. The pointer in the structure that is returned is a pointer to dynamically allocated memory block. This DBM interface uses the NDBM interface. */ datum fetch (key) datum key; { datum ret_val; /* The return value. */ /* Free previous dynamic memory, do actual call, and save pointer to new memory. */ ret_val = gdbm_fetch (_gdbm_file, key); if (_gdbm_fetch_val != NULL) free (_gdbm_fetch_val); _gdbm_fetch_val = ret_val.dptr; /* Return the new value. */ return ret_val; } gdbm-1.7.2/store.c100600 24413 24 3141 5471123632 12463 0ustar downsjuser/* store.c - Add a new key/data pair to the database. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "extern.h" /* Add a new element to the database. CONTENT is keyed by KEY. The file on disk is updated to reflect the structure of the new database before returning from this procedure. */ int store (key, content) datum key; datum content; { return gdbm_store (_gdbm_file, key, content, GDBM_REPLACE); } gdbm-1.7.2/seq.c100600 24413 24 4412 5507306016 12120 0ustar downsjuser/* seq.c - This is the sequential visit of the database. This defines two user-visable routines that are used together. This is the DBM interface. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "extern.h" /* Start the visit of all keys in the database. This produces something in hash order, not in any sorted order. */ datum firstkey () { datum ret_val; /* Free previous dynamic memory, do actual call, and save pointer to new memory. */ ret_val = gdbm_firstkey (_gdbm_file); if (_gdbm_memory.dptr != NULL) free (_gdbm_memory.dptr); _gdbm_memory = ret_val; /* Return the new value. */ return ret_val; } /* Continue visiting all keys. The next key following KEY is returned. */ datum nextkey (key) datum key; { datum ret_val; /* Make sure we have a valid key. */ if (key.dptr == NULL) return key; /* Call gdbm nextkey with supplied value. After that, free the old value. */ ret_val = gdbm_nextkey (_gdbm_file, key); if (_gdbm_memory.dptr != NULL) free (_gdbm_memory.dptr); _gdbm_memory = ret_val; /* Return the new value. */ return ret_val; } gdbm-1.7.2/close.c100600 24413 24 3315 5507300241 12430 0ustar downsjuser/* close.c - Close the "original" style database. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the original author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 The author of this file is: e-mail: downsj@csos.orst.edu *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "extern.h" /* it's unclear whether dbmclose() is *always* a void function in old C libraries. we use int, here. */ int dbmclose() { if (_gdbm_file != NULL) { gdbm_close (_gdbm_file); _gdbm_file = NULL; if (_gdbm_memory.dptr != NULL) free(_gdbm_memory.dptr); _gdbm_memory.dptr = NULL; _gdbm_memory.dsize = 0; } return (0); } gdbm-1.7.2/dbmopen.c100600 24413 24 10731 5471125600 12773 0ustar downsjuser/* dbmopen.c - Open the file for dbm operations. This looks like the NDBM interface for dbm use. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" #include "extern.h" /* Initialize ndbm system. FILE is a pointer to the file name. In standard dbm, the database is found in files called FILE.pag and FILE.dir. To make gdbm compatable with dbm using the dbminit call, the same file names are used. Specifically, dbminit will use the file name FILE.pag in its call to gdbm open. If the file (FILE.pag) has a size of zero bytes, a file initialization procedure is performed, setting up the initial structure in the file. Any error detected will cause a return value of -1. No errors cause the return value of 0. NOTE: file.dir will be ignored and will always have a size of zero. FLAGS and MODE are the same as the open (2) call. This call will look at the FLAGS and decide what call to make to gdbm_open. For FLAGS == O_RDONLY, it will be a GDBM_READER, if FLAGS == O_RDWR|O_CREAT, it will be a GDBM_WRCREAT (creater and writer) and if the FLAGS == O_RDWR, it will be a GDBM_WRITER and if FLAGS contain O_TRUNC then it will be a GDBM_NEWDB. All other values of FLAGS in the flags are ignored. */ gdbm_file_info * dbm_open (file, flags, mode) char *file; int flags; int mode; { char* pag_file; /* Used to construct "file.pag". */ char* dir_file; /* Used to construct "file.dir". */ struct stat dir_stat; /* Stat information for "file.dir". */ gdbm_file_info *temp_dbf; /* Temporary file pointer storage. */ /* Prepare the correct names of "file.pag" and "file.dir". */ pag_file = (char *) alloca (strlen (file)+5); dir_file = (char *) alloca (strlen (file)+5); strcpy (pag_file, file); strcat (pag_file, ".pag"); strcpy (dir_file, file); strcat (dir_file, ".dir"); /* Call the actual routine, saving the pointer to the file information. */ flags &= O_RDONLY | O_RDWR | O_CREAT | O_TRUNC; if (flags == O_RDONLY) { temp_dbf = gdbm_open (pag_file, 0, GDBM_READER, 0, NULL); } else if (flags == (O_RDWR | O_CREAT)) { temp_dbf = gdbm_open (pag_file, 0, GDBM_WRCREAT, mode, NULL); } else if ( (flags & O_TRUNC) == O_TRUNC) { temp_dbf = gdbm_open (pag_file, 0, GDBM_NEWDB, mode, NULL); } else { temp_dbf = gdbm_open (pag_file, 0, GDBM_WRITER, 0, NULL); } /* Did we successfully open the file? */ if (temp_dbf == NULL) { gdbm_errno = GDBM_FILE_OPEN_ERROR; return NULL; } /* If the database is new, link "file.dir" to "file.pag". This is done so the time stamp on both files is the same. */ if (stat (dir_file, &dir_stat) == 0) { if (dir_stat.st_size == 0) if (unlink (dir_file) != 0 || link (pag_file, dir_file) != 0) { gdbm_errno = GDBM_FILE_OPEN_ERROR; gdbm_close (temp_dbf); return NULL; } } else { /* Since we can't stat it, we assume it is not there and try to link the dir_file to the pag_file. */ if (link (pag_file, dir_file) != 0) { gdbm_errno = GDBM_FILE_OPEN_ERROR; gdbm_close (temp_dbf); return NULL; } } return temp_dbf; } gdbm-1.7.2/dbmdelete.c100600 24413 24 3015 5507303723 13255 0ustar downsjuser/* dbmdelete.c - Remove the key and its associated data from the database. This is the NDBM unix interface name. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "extern.h" /* Remove the KEYed item and the KEY from the database DBF. */ int dbm_delete (dbf,key) gdbm_file_info *dbf; datum key; { return gdbm_delete (dbf,key); } gdbm-1.7.2/dbmfetch.c100600 24413 24 3745 5507303766 13125 0ustar downsjuser/* dbmfetch.c - Find a key and return the associated data. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "extern.h" /* NDBM Look up a given KEY and return the information associated with that KEY. The pointer in the structure that is returned is a pointer to dynamically allocated memory block. */ datum dbm_fetch (dbf, key) gdbm_file_info *dbf; datum key; { datum ret_val; /* The return value. */ /* Free previous dynamic memory, do actual call, and save pointer to new memory. */ ret_val = gdbm_fetch (dbf, key); if (_gdbm_fetch_val != NULL) free (_gdbm_fetch_val); _gdbm_fetch_val = ret_val.dptr; /* Return the new value. */ return ret_val; } gdbm-1.7.2/dbmstore.c100600 24413 24 3224 5471122737 13155 0ustar downsjuser/* dbmstore.c - Add a new key/data pair to the database. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "extern.h" /* NDBM add a new element to the database. CONTENT is keyed by KEY. The file on disk is updated to reflect the structure of the new database before returning from this procedure. */ int dbm_store (dbf, key, content, flags) gdbm_file_info *dbf; datum key; datum content; int flags; { return gdbm_store (dbf, key, content, flags); } gdbm-1.7.2/dbmseq.c100600 24413 24 4541 5471122722 12606 0ustar downsjuser/* dbmseq.c - Visit all elements in the database. This is the NDBM interface. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "extern.h" /* NDBM Start the visit of all keys in the database. This produces something in hash order, not in any sorted order. DBF is the dbm file information pointer. */ datum dbm_firstkey (dbf) gdbm_file_info *dbf; { datum ret_val; /* Free previous dynamic memory, do actual call, and save pointer to new memory. */ ret_val = gdbm_firstkey (dbf); if (_gdbm_memory.dptr != NULL) free (_gdbm_memory.dptr); _gdbm_memory = ret_val; /* Return the new value. */ return ret_val; } /* NDBM Continue visiting all keys. The next key in the sequence is returned. DBF is the file information pointer. */ datum dbm_nextkey (dbf) gdbm_file_info *dbf; { datum ret_val; /* Make sure we have a valid key. */ if (_gdbm_memory.dptr == NULL) return _gdbm_memory; /* Call gdbm nextkey with the old value. After that, free the old value. */ ret_val = gdbm_nextkey (dbf,_gdbm_memory); if (_gdbm_memory.dptr != NULL) free (_gdbm_memory.dptr); _gdbm_memory = ret_val; /* Return the new value. */ return ret_val; } gdbm-1.7.2/dbmclose.c100600 24413 24 2576 5507303703 13131 0ustar downsjuser/* dbmclose.c - The the dbm file. This is the NDBM interface. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" /* Close the DBF file. */ void dbm_close (dbf) gdbm_file_info *dbf; { gdbm_close (dbf); } gdbm-1.7.2/dbmdirfno.c100600 24413 24 2761 5507303737 13310 0ustar downsjuser/* dbmdirfno.c - The .pag file number for NDBM interface. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" /* Return the file number of the DBF file. NDBM original wanted the .dir file number. Since we have only one file number, we return it. */ int dbm_dirfno (dbf) gdbm_file_info *dbf; { return (dbf->desc); } gdbm-1.7.2/dbmpagfno.c100600 24413 24 2761 5507304065 13274 0ustar downsjuser/* dbmpagfno.c - The .pag file number for NDBM interface. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" /* Return the file number of the DBF file. NDBM original wanted the .pag file number. Since we have only one file number, we return it. */ int dbm_pagfno (dbf) gdbm_file_info *dbf; { return (dbf->desc); } gdbm-1.7.2/dbmrdonly.c100600 24413 24 3014 5507304111 13311 0ustar downsjuser/* dbmrdonly.c - Check to see if a database is read only, NDBM style. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the original author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 The author of this file is: e-mail: downsj@csos.orst.edu *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" /* not much of a routine, but should be a function for compatibility. */ int dbm_rdonly(dbf) gdbm_file_info *dbf; { return (dbf->read_write == GDBM_READER); } gdbm-1.7.2/gdbmopen.c100600 24413 24 31557 5507305074 13160 0ustar downsjuser/* gdbmopen.c - Open the dbm file and initialize data structures for use. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" /* Initialize dbm system. FILE is a pointer to the file name. If the file has a size of zero bytes, a file initialization procedure is performed, setting up the initial structure in the file. BLOCK_SIZE is used during initialization to determine the size of various constructs. If the value is less than 512, the file system blocksize is used, otherwise the value of BLOCK_SIZE is used. BLOCK_SIZE is ignored if the file has previously initialized. If FLAGS is set to GDBM_READ the user wants to just read the database and any call to dbm_store or dbm_delete will fail. Many readers can access the database at the same time. If FLAGS is set to GDBM_WRITE, the user wants both read and write access to the database and requires exclusive access. If FLAGS is GDBM_WRCREAT, the user wants both read and write access to the database and if the database does not exist, create a new one. If FLAGS is GDBM_NEWDB, the user want a new database created, regardless of whether one existed, and wants read and write access to the new database. Any error detected will cause a return value of null and an approprate value will be in gdbm_errno. If no errors occur, a pointer to the "gdbm file descriptor" will be returned. */ gdbm_file_info * gdbm_open (file, block_size, flags, mode, fatal_func) char *file; int block_size; int flags; int mode; void (*fatal_func) (); { gdbm_file_info *dbf; /* The record to return. */ struct stat file_stat; /* Space for the stat information. */ int len; /* Length of the file name. */ int num_bytes; /* Used in reading and writing. */ off_t file_pos; /* Used with seeks. */ int lock_val; /* Returned by the flock call. */ int file_block_size; /* Block size to use for a new file. */ int index; /* Used as a loop index. */ char need_trunc; /* Used with GDBM_NEWDB and locking to avoid truncating a file from under a reader. */ /* Initialize the gdbm_errno variable. */ gdbm_errno = GDBM_NO_ERROR; /* Allocate new info structure. */ dbf = (gdbm_file_info *) malloc (sizeof (gdbm_file_info)); if (dbf == NULL) { gdbm_errno = GDBM_MALLOC_ERROR; return NULL; } /* Initialize some fields for known values. This is done so gdbm_close will work if called before allocating some structures. */ dbf->dir = NULL; dbf->bucket = NULL; dbf->header = NULL; dbf->bucket_cache = NULL; dbf->cache_size = 0; /* Save name of file. */ len = strlen (file); dbf->name = (char *) malloc (len + 1); if (dbf->name == NULL) { free (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL; } strcpy (dbf->name, file); /* Initialize the fatal error routine. */ dbf->fatal_err = fatal_func; /* Check for fast writers. */ if (flags & GDBM_FAST) { dbf->fast_write = TRUE; flags -= GDBM_FAST; } else { dbf->fast_write = FALSE; } /* Open the file. */ need_trunc = FALSE; if (flags == GDBM_READER) { dbf->desc = open (dbf->name, O_RDONLY, 0); } else if (flags == GDBM_WRITER) { dbf->desc = open (dbf->name, O_RDWR, 0); } else if (flags == GDBM_NEWDB) { dbf->desc = open (dbf->name, O_RDWR|O_CREAT, mode); flags = GDBM_WRITER; need_trunc = TRUE; } else { dbf->desc = open (dbf->name, O_RDWR|O_CREAT, mode); flags = GDBM_WRITER; } if (dbf->desc < 0) { free (dbf->name); free (dbf); gdbm_errno = GDBM_FILE_OPEN_ERROR; return NULL; } /* Get the status of the file. */ fstat (dbf->desc, &file_stat); /* Lock the file in the approprate way. */ if (flags == GDBM_READER) { if (file_stat.st_size == 0) { close (dbf->desc); free (dbf->name); free (dbf); gdbm_errno = GDBM_EMPTY_DATABASE; return NULL; } /* Sets lock_val to 0 for success. See systems.h. */ READLOCK_FILE(dbf); } else { /* Sets lock_val to 0 for success. See systems.h. */ WRITELOCK_FILE(dbf); } if (lock_val != 0) { close (dbf->desc); free (dbf->name); free (dbf); if (flags == GDBM_READER) gdbm_errno = GDBM_CANT_BE_READER; else gdbm_errno = GDBM_CANT_BE_WRITER; return NULL; } /* Record the kind of user. */ dbf->read_write = flags; /* If we do have a write lock and it was a GDBM_NEWDB, it is now time to truncate the file. */ if (need_trunc && file_stat.st_size != 0) { TRUNCATE (dbf); fstat (dbf->desc, &file_stat); } /* Decide if this is a new file or an old file. */ if (file_stat.st_size == 0) { /* This is a new file. Create an empty database. */ /* Start with the blocksize. */ if (block_size < 512) file_block_size = STATBLKSIZE; else file_block_size = block_size; /* Get space for the file header. */ dbf->header = (gdbm_file_header *) malloc (file_block_size); if (dbf->header == NULL) { gdbm_close (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL; } /* Set the magic number and the block_size. */ dbf->header->header_magic = 0x13579ace; dbf->header->block_size = file_block_size; /* Create the initial hash table directory. */ dbf->header->dir_size = 8 * sizeof (off_t); dbf->header->dir_bits = 3; while (dbf->header->dir_size < dbf->header->block_size) { dbf->header->dir_size <<= 1; dbf->header->dir_bits += 1; } /* Check for correct block_size. */ if (dbf->header->dir_size != dbf->header->block_size) { gdbm_close (dbf); gdbm_errno = GDBM_BLOCK_SIZE_ERROR; return NULL; } /* Allocate the space for the directory. */ dbf->dir = (off_t *) malloc (dbf->header->dir_size); if (dbf->dir == NULL) { gdbm_close (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL; } dbf->header->dir = dbf->header->block_size; /* Create the first and only hash bucket. */ dbf->header->bucket_elems = (dbf->header->block_size - sizeof (hash_bucket)) / sizeof (bucket_element) + 1; dbf->header->bucket_size = dbf->header->block_size; #if !defined(sgi) dbf->bucket = (hash_bucket *) (alloca (dbf->header->bucket_size)); #else /* sgi */ /* The SGI C compiler doesn't accept the previous form. */ { hash_bucket *ptr; ptr = (hash_bucket *) (alloca (dbf->header->bucket_size)); dbf->bucket = ptr; } #endif /* sgi */ if (dbf->bucket == NULL) { gdbm_close (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL; } _gdbm_new_bucket (dbf, dbf->bucket, 0); dbf->bucket->av_count = 1; dbf->bucket->bucket_avail[0].av_adr = 3*dbf->header->block_size; dbf->bucket->bucket_avail[0].av_size = dbf->header->block_size; /* Set table entries to point to hash buckets. */ for (index = 0; index < dbf->header->dir_size / sizeof (off_t); index++) dbf->dir[index] = 2*dbf->header->block_size; /* Initialize the active avail block. */ dbf->header->avail.size = ( (dbf->header->block_size - sizeof (gdbm_file_header)) / sizeof (avail_elem)) + 1; dbf->header->avail.count = 0; dbf->header->avail.next_block = 0; dbf->header->next_block = 4*dbf->header->block_size; /* Write initial configuration to the file. */ /* Block 0 is the file header and active avail block. */ num_bytes = write (dbf->desc, dbf->header, dbf->header->block_size); if (num_bytes != dbf->header->block_size) { gdbm_close (dbf); gdbm_errno = GDBM_FILE_WRITE_ERROR; return NULL; } /* Block 1 is the initial bucket directory. */ num_bytes = write (dbf->desc, dbf->dir, dbf->header->dir_size); if (num_bytes != dbf->header->dir_size) { gdbm_close (dbf); gdbm_errno = GDBM_FILE_WRITE_ERROR; return NULL; } /* Block 2 is the only bucket. */ num_bytes = write (dbf->desc, dbf->bucket, dbf->header->bucket_size); if (num_bytes != dbf->header->bucket_size) { gdbm_close (dbf); gdbm_errno = GDBM_FILE_WRITE_ERROR; return NULL; } /* Wait for initial configuration to be written to disk. */ fsync (dbf->desc); } else { /* This is an old database. Read in the information from the file header and initialize the hash directory. */ gdbm_file_header partial_header; /* For the first part of it. */ /* Read the partial file header. */ num_bytes = read (dbf->desc, &partial_header, sizeof (gdbm_file_header)); if (num_bytes != sizeof (gdbm_file_header)) { gdbm_close (dbf); gdbm_errno = GDBM_FILE_READ_ERROR; return NULL; } /* Is the magic number good? */ if (partial_header.header_magic != 0x13579ace) { gdbm_close (dbf); gdbm_errno = GDBM_BAD_MAGIC_NUMBER; return NULL; } /* It is a good database, read the entire header. */ dbf->header = (gdbm_file_header *) malloc (partial_header.block_size); if (dbf->header == NULL) { gdbm_close (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL; } bcopy (&partial_header, dbf->header, sizeof (gdbm_file_header)); num_bytes = read (dbf->desc, &dbf->header->avail.av_table[1], dbf->header->block_size-sizeof (gdbm_file_header)); if (num_bytes != dbf->header->block_size-sizeof (gdbm_file_header)) { gdbm_close (dbf); gdbm_errno = GDBM_FILE_READ_ERROR; return NULL; } /* Allocate space for the hash table directory. */ dbf->dir = (off_t *) malloc (dbf->header->dir_size); if (dbf->dir == NULL) { gdbm_close (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL; } /* Read the hash table directory. */ file_pos = lseek (dbf->desc, dbf->header->dir, L_SET); if (file_pos != dbf->header->dir) { gdbm_close (dbf); gdbm_errno = GDBM_FILE_SEEK_ERROR; return NULL; } num_bytes = read (dbf->desc, dbf->dir, dbf->header->dir_size); if (num_bytes != dbf->header->dir_size) { gdbm_close (dbf); gdbm_errno = GDBM_FILE_READ_ERROR; return NULL; } } /* Finish initializing dbf. */ dbf->last_read = -1; dbf->bucket = NULL; dbf->bucket_dir = 0; dbf->cache_entry = NULL; dbf->header_changed = FALSE; dbf->directory_changed = FALSE; dbf->bucket_changed = FALSE; dbf->second_changed = FALSE; /* Everything is fine, return the pointer to the file information structure. */ return dbf; } /* initialize the bucket cache. */ int _gdbm_init_cache(dbf, size) gdbm_file_info *dbf; int size; { register int index; if (dbf->bucket_cache == NULL) { dbf->bucket_cache = (cache_elem *) malloc(sizeof(cache_elem) * size); if(dbf->bucket_cache == NULL) { gdbm_errno = GDBM_MALLOC_ERROR; return(-1); } dbf->cache_size = size; for(index = 0; index < size; index++) { (dbf->bucket_cache[index]).ca_bucket = (hash_bucket *) malloc (dbf->header->bucket_size); if ((dbf->bucket_cache[index]).ca_bucket == NULL) { gdbm_errno = GDBM_MALLOC_ERROR; return(-1); } (dbf->bucket_cache[index]).ca_adr = 0; (dbf->bucket_cache[index]).ca_changed = FALSE; (dbf->bucket_cache[index]).ca_data.hash_val = -1; (dbf->bucket_cache[index]).ca_data.elem_loc = -1; (dbf->bucket_cache[index]).ca_data.dptr = NULL; } dbf->bucket = dbf->bucket_cache[0].ca_bucket; dbf->cache_entry = &dbf->bucket_cache[0]; } return(0); } gdbm-1.7.2/gdbmdelete.c100600 24413 24 7471 5507256041 13436 0ustar downsjuser/* gdbmdelete.c - Remove the key and its associated data from the database. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" /* Remove the KEYed item and the KEY from the database DBF. The file on disk is updated to reflect the structure of the new database before returning from this procedure. */ int gdbm_delete (dbf, key) gdbm_file_info *dbf; datum key; { int elem_loc; /* The location in the current hash bucket. */ int last_loc; /* Last location emptied by the delete. */ int home; /* Home position of an item. */ bucket_element elem; /* The element to be deleted. */ char *find_data; /* Return pointer from findkey. */ word_t hash_val; /* Returned by findkey. */ off_t free_adr; /* Temporary stroage for address and size. */ int free_size; /* First check to make sure this guy is a writer. */ if (dbf->read_write != GDBM_WRITER) { gdbm_errno = GDBM_READER_CANT_DELETE; return -1; } /* Initialize the gdbm_errno variable. */ gdbm_errno = GDBM_NO_ERROR; /* Find the item. */ elem_loc = _gdbm_findkey (dbf, key, &find_data, &hash_val); if (elem_loc == -1) { gdbm_errno = GDBM_ITEM_NOT_FOUND; return -1; } /* Save the element. */ elem = dbf->bucket->h_table[elem_loc]; /* Delete the element. */ dbf->bucket->h_table[elem_loc].hash_value = -1; dbf->bucket->count -= 1; /* Move other elements to guarantee that they can be found. */ last_loc = elem_loc; elem_loc = (elem_loc + 1) % dbf->header->bucket_elems; while (elem_loc != last_loc && dbf->bucket->h_table[elem_loc].hash_value != -1) { home = dbf->bucket->h_table[elem_loc].hash_value % dbf->header->bucket_elems; if ( (last_loc < elem_loc && (home <= last_loc || home > elem_loc)) || (last_loc > elem_loc && home <= last_loc && home > elem_loc)) { dbf->bucket->h_table[last_loc] = dbf->bucket->h_table[elem_loc]; dbf->bucket->h_table[elem_loc].hash_value = -1; last_loc = elem_loc; } elem_loc = (elem_loc + 1) % dbf->header->bucket_elems; } /* Free the file space. */ free_adr = elem.data_pointer; free_size = elem.key_size + elem.data_size; _gdbm_free (dbf, free_adr, free_size); /* Set the flags. */ dbf->bucket_changed = TRUE; /* Clear out the data cache for the current bucket. */ if (dbf->cache_entry->ca_data.dptr != NULL) { free (dbf->cache_entry->ca_data.dptr); dbf->cache_entry->ca_data.dptr = NULL; } dbf->cache_entry->ca_data.hash_val = -1; dbf->cache_entry->ca_data.key_size = 0; dbf->cache_entry->ca_data.elem_loc = -1; /* Do the writes. */ _gdbm_end_update (dbf); return 0; } gdbm-1.7.2/gdbmfetch.c100600 24413 24 5356 5507304556 13272 0ustar downsjuser/* gdbmfetch.c - Find a key and return the associated data. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" /* Look up a given KEY and return the information associated with that KEY. The pointer in the structure that is returned is a pointer to dynamically allocated memory block. */ datum gdbm_fetch (dbf, key) gdbm_file_info *dbf; datum key; { datum return_val; /* The return value. */ int elem_loc; /* The location in the bucket. */ char *find_data; /* Returned from find_key. */ word_t hash_val; /* Returned from find_key. */ /* Set the default return value. */ return_val.dptr = NULL; return_val.dsize = 0; /* Initialize the gdbm_errno variable. */ gdbm_errno = GDBM_NO_ERROR; /* Find the key and return a pointer to the data. */ elem_loc = _gdbm_findkey (dbf, key, &find_data, &hash_val); /* Copy the data if the key was found. */ if (elem_loc >= 0) { /* This is the item. Return the associated data. */ return_val.dsize = dbf->bucket->h_table[elem_loc].data_size; if (return_val.dsize == 0) return_val.dptr = (char *) malloc (1); else return_val.dptr = (char *) malloc (return_val.dsize); if (return_val.dptr == NULL) _gdbm_fatal (dbf, "malloc error"); bcopy (find_data, return_val.dptr, return_val.dsize); } /* Check for an error and return. */ if (return_val.dptr == NULL) gdbm_errno = GDBM_ITEM_NOT_FOUND; return return_val; } gdbm-1.7.2/gdbmstore.c100600 24413 24 13455 5471125750 13351 0ustar downsjuser/* gdbmstore.c - Add a new key/data pair to the database. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" /* Add a new element to the database. CONTENT is keyed by KEY. The file on disk is updated to reflect the structure of the new database before returning from this procedure. The FLAGS define the action to take when the KEY is already in the database. The value GDBM_REPLACE asks that the old data be replaced by the new CONTENT. The value GDBM_INSERT asks that an error be returned and no action taken. A return value of 0 means no errors. A return value of -1 means that the item was not stored in the data base because the caller was not an official writer. A return value of 0 means that the item was not stored because the argument FLAGS was GDBM_INSERT and the KEY was already in the database. */ int gdbm_store (dbf, key, content, flags) gdbm_file_info *dbf; datum key; datum content; int flags; { word_t new_hash_val; /* The new hash value. */ int elem_loc; /* The location in hash bucket. */ off_t file_adr; /* The address of new space in the file. */ off_t file_pos; /* The position after a lseek. */ int num_bytes; /* Used for error detection. */ off_t free_adr; /* For keeping track of a freed section. */ int free_size; /* char *write_data; */ /* To write both key and data in 1 call. */ /* char *src; */ /* Used to prepare write_data. */ /* char *dst; */ /* Used to prepare write_data. */ /* int cnt; */ /* Counter for loops to fill write_data. */ int new_size; /* Used in allocating space. */ char *temp; /* Used in _gdbm_findkey call. */ /* First check to make sure this guy is a writer. */ if (dbf->read_write != GDBM_WRITER) { gdbm_errno = GDBM_READER_CANT_STORE; return -1; } /* Check for illegal data values. A NULL dptr field is illegal because NULL dptr returned by a lookup procedure indicates an error. */ if ((key.dptr == NULL) || (content.dptr == NULL)) { gdbm_errno = GDBM_ILLEGAL_DATA; return -1; } /* Initialize the gdbm_errno variable. */ gdbm_errno = GDBM_NO_ERROR; /* Look for the key in the file. A side effect loads the correct bucket and calculates the hash value. */ elem_loc = _gdbm_findkey (dbf, key, &temp, &new_hash_val); /* Did we find the item? */ if (elem_loc != -1) { if (flags == GDBM_REPLACE) { /* Just replace the data. */ free_adr = dbf->bucket->h_table[elem_loc].data_pointer; free_size = dbf->bucket->h_table[elem_loc].key_size + dbf->bucket->h_table[elem_loc].data_size; _gdbm_free (dbf, free_adr, free_size); } else { gdbm_errno = GDBM_CANNOT_REPLACE; return 1; } } /* Get the file address for the new space. (Current bucket's free space is first place to look.) */ new_size = key.dsize+content.dsize; file_adr = _gdbm_alloc (dbf, new_size); /* If this is a new entry in the bucket, we need to do special things. */ if (elem_loc == -1) { if (dbf->bucket->count == dbf->header->bucket_elems) { /* Split the current bucket. */ _gdbm_split_bucket (dbf, new_hash_val); } /* Find space to insert into bucket and set elem_loc to that place. */ elem_loc = new_hash_val % dbf->header->bucket_elems; while (dbf->bucket->h_table[elem_loc].hash_value != -1) { elem_loc = (elem_loc + 1) % dbf->header->bucket_elems; } /* We now have another element in the bucket. Add the new information.*/ dbf->bucket->count += 1; dbf->bucket->h_table[elem_loc].hash_value = new_hash_val; bcopy (key.dptr, dbf->bucket->h_table[elem_loc].key_start, (SMALL < key.dsize ? SMALL : key.dsize)); } /* Update current bucket data pointer and sizes. */ dbf->bucket->h_table[elem_loc].data_pointer = file_adr; dbf->bucket->h_table[elem_loc].key_size = key.dsize; dbf->bucket->h_table[elem_loc].data_size = content.dsize; /* Write the data to the file. */ file_pos = lseek (dbf->desc, file_adr, L_SET); if (file_pos != file_adr) _gdbm_fatal (dbf, "lseek error"); num_bytes = write (dbf->desc, key.dptr, key.dsize); if (num_bytes != key.dsize) _gdbm_fatal (dbf, "write error"); num_bytes = write (dbf->desc, content.dptr, content.dsize); if (num_bytes != content.dsize) _gdbm_fatal (dbf, "write error"); /* Current bucket has changed. */ dbf->cache_entry->ca_changed = TRUE; dbf->bucket_changed = TRUE; /* Write everything that is needed to the disk. */ _gdbm_end_update (dbf); return 0; } gdbm-1.7.2/gdbmclose.c100600 24413 24 4461 5471125657 13305 0ustar downsjuser/* gdbmclose.c - Close a previously opened dbm file. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" /* Close the dbm file and free all memory associated with the file DBF. Before freeing members of DBF, check and make sure that they were allocated. */ void gdbm_close (dbf) gdbm_file_info *dbf; { register int index; /* For freeing the bucket cache. */ /* Make sure the database is all on disk. */ if (dbf->read_write == GDBM_WRITER) fsync (dbf->desc); /* Close the file and free all malloced memory. */ UNLOCK_FILE(dbf); close (dbf->desc); free (dbf->name); if (dbf->dir != NULL) free (dbf->dir); if (dbf->bucket_cache != NULL) { for (index = 0; index < dbf->cache_size; index++) { if (dbf->bucket_cache[index].ca_bucket != NULL) free (dbf->bucket_cache[index].ca_bucket); if (dbf->bucket_cache[index].ca_data.dptr != NULL) free (dbf->bucket_cache[index].ca_data.dptr); } free (dbf->bucket_cache); } if ( dbf->header != NULL ) free (dbf->header); free (dbf); } gdbm-1.7.2/gdbmreorg.c100600 24413 24 13755 5507305213 13330 0ustar downsjuser/* gdbmreorg.c - Reorganize the database file. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 ************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" #include "extern.h" #if !HAVE_RENAME /* Rename takes OLD_NAME and renames it as NEW_NAME. If it can not rename the file a non-zero value is returned. OLD_NAME is guaranteed to remain if it can't be renamed. It assumes NEW_NAME always exists (due to being used in gdbm). */ static int rename (old_name, new_name) char* old_name; char* new_name; { if (unlink (new_name) != 0) return -1; if (link (old_name, new_name) != 0) return -1; unlink (old_name); return 0; } #endif /* Reorganize the database. This requires creating a new file and inserting all the elements in the old file DBF into the new file. The new file is then renamed to the same name as the old file and DBF is updated to contain all the correct information about the new file. If an error is detected, the return value is negative. The value zero is returned after a successful reorganization. */ int gdbm_reorganize (dbf) gdbm_file_info *dbf; { gdbm_file_info *new_dbf; /* The new file. */ char *new_name; /* A temporary name. */ int len; /* Used in new_name construction. */ datum key, nextkey, data; /* For the sequential sweep. */ struct stat fileinfo; /* Information about the file. */ int index; /* Use in moving the bucket cache. */ /* Readers can not reorganize! */ if (dbf->read_write == GDBM_READER) { gdbm_errno = GDBM_READER_CANT_REORGANIZE; return -1; } /* Initialize the gdbm_errno variable. */ gdbm_errno = GDBM_NO_ERROR; /* Construct new name for temporary file. */ len = strlen (dbf->name); new_name = (char *) alloca (len + 3); if (new_name == NULL) { gdbm_errno = GDBM_MALLOC_ERROR; return -1; } strcpy (&new_name[0], dbf->name); new_name[len+2] = 0; new_name[len+1] = '#'; while ( (len > 0) && new_name[len-1] != '/') { new_name[len] = new_name[len-1]; len -= 1; } new_name[len] = '#'; /* Get the mode for the old file and open the new database. The "fast" mode is used because the reorganization will fail unless we create a complete copy of the database. */ fstat (dbf->desc, &fileinfo); new_dbf = gdbm_open (new_name, dbf->header->block_size, GDBM_WRCREAT | GDBM_FAST, fileinfo.st_mode, dbf->fatal_err); if (new_dbf == NULL) { gdbm_errno = GDBM_REORGANIZE_FAILED; return -1; } /* For each item in the old database, add an entry in the new. */ key = gdbm_firstkey (dbf); while (key.dptr != NULL) { data = gdbm_fetch (dbf, key); if (data.dptr != NULL) { /* Add the data to the new file. */ if (gdbm_store (new_dbf, key, data, GDBM_INSERT) != 0) { gdbm_close (new_dbf); gdbm_errno = GDBM_REORGANIZE_FAILED; unlink (new_name); return -1; } } else { /* ERROR! Abort and don't finish reorganize. */ gdbm_close (new_dbf); gdbm_errno = GDBM_REORGANIZE_FAILED; unlink (new_name); return -1; } nextkey = gdbm_nextkey (dbf, key); free (key.dptr); free (data.dptr); key = nextkey; } /* Write everything. */ _gdbm_end_update (new_dbf); gdbm_sync (new_dbf); /* Move the new file to old name. */ if (rename (new_name, dbf->name) != 0) { gdbm_errno = GDBM_REORGANIZE_FAILED; gdbm_close (new_dbf); return -1; } /* Fix up DBF to have the correct information for the new file. */ UNLOCK_FILE(dbf); close (dbf->desc); free (dbf->header); free (dbf->dir); if (dbf->bucket_cache != NULL) { for (index = 0; index < dbf->cache_size; index++) { if (dbf->bucket_cache[index].ca_bucket != NULL) free (dbf->bucket_cache[index].ca_bucket); if (dbf->bucket_cache[index].ca_data.dptr != NULL) free (dbf->bucket_cache[index].ca_data.dptr); } free (dbf->bucket_cache); } dbf->desc = new_dbf->desc; dbf->header = new_dbf->header; dbf->dir = new_dbf->dir; dbf->bucket = new_dbf->bucket; dbf->bucket_dir = new_dbf->bucket_dir; dbf->last_read = new_dbf->last_read; dbf->bucket_cache = new_dbf->bucket_cache; dbf->cache_size = new_dbf->cache_size; dbf->header_changed = new_dbf->header_changed; dbf->directory_changed = new_dbf->directory_changed; dbf->bucket_changed = new_dbf->bucket_changed; dbf->second_changed = new_dbf->second_changed; free (new_dbf); /* Make sure the new database is all on disk. */ fsync (dbf->desc); /* Force the right stuff for a correct bucket cache. */ dbf->cache_entry = &dbf->bucket_cache[0]; _gdbm_get_bucket (dbf, 0); return 0; } gdbm-1.7.2/gdbmseq.c100600 24413 24 10651 5507305362 12777 0ustar downsjuser/* gdbmseq.c - Routines to visit all keys. Not in sorted order. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" /* Special extern for this file. */ extern char *_gdbm_read_entry _ARGS((gdbm_file_info *, int)); /* Find and read the next entry in the hash structure for DBF starting at ELEM_LOC of the current bucket and using RETURN_VAL as the place to put the data that is found. */ static void get_next_key (dbf, elem_loc, return_val) gdbm_file_info *dbf; int elem_loc; datum *return_val; { int found; /* Have we found the next key. */ char *find_data; /* Data pointer returned by find_key. */ /* Find the next key. */ found = FALSE; while (!found) { /* Advance to the next location in the bucket. */ elem_loc++; if (elem_loc == dbf->header->bucket_elems) { /* We have finished the current bucket, get the next bucket. */ elem_loc = 0; /* Find the next bucket. It is possible several entries in the bucket directory point to the same bucket. */ while (dbf->bucket_dir < dbf->header->dir_size / sizeof (off_t) && dbf->cache_entry->ca_adr == dbf->dir[dbf->bucket_dir]) dbf->bucket_dir++; /* Check to see if there was a next bucket. */ if (dbf->bucket_dir < dbf->header->dir_size / sizeof (off_t)) _gdbm_get_bucket (dbf, dbf->bucket_dir); else /* No next key, just return. */ return ; } found = dbf->bucket->h_table[elem_loc].hash_value != -1; } /* Found the next key, read it into return_val. */ find_data = _gdbm_read_entry (dbf, elem_loc); return_val->dsize = dbf->bucket->h_table[elem_loc].key_size; if (return_val->dsize == 0) return_val->dptr = (char *) malloc (1); else return_val->dptr = (char *) malloc (return_val->dsize); if (return_val->dptr == NULL) _gdbm_fatal (dbf, "malloc error"); bcopy (find_data, return_val->dptr, return_val->dsize); } /* Start the visit of all keys in the database. This produces something in hash order, not in any sorted order. */ datum gdbm_firstkey (dbf) gdbm_file_info *dbf; { datum return_val; /* To return the first key. */ /* Set the default return value for not finding a first entry. */ return_val.dptr = NULL; /* Initialize the gdbm_errno variable. */ gdbm_errno = GDBM_NO_ERROR; /* Get the first bucket. */ _gdbm_get_bucket (dbf, 0); /* Look for first entry. */ get_next_key (dbf, -1, &return_val); return return_val; } /* Continue visiting all keys. The next key following KEY is returned. */ datum gdbm_nextkey (dbf, key) gdbm_file_info *dbf; datum key; { datum return_val; /* The return value. */ int elem_loc; /* The location in the bucket. */ char *find_data; /* Data pointer returned by _gdbm_findkey. */ word_t hash_val; /* Returned by _gdbm_findkey. */ /* Initialize the gdbm_errno variable. */ gdbm_errno = GDBM_NO_ERROR; /* Set the default return value for no next entry. */ return_val.dptr = NULL; /* Do we have a valid key? */ if (key.dptr == NULL) return return_val; /* Find the key. */ elem_loc = _gdbm_findkey (dbf, key, &find_data, &hash_val); if (elem_loc == -1) return return_val; /* Find the next key. */ get_next_key (dbf, elem_loc, &return_val); return return_val; } gdbm-1.7.2/gdbmsync.c100600 24413 24 3017 5471123344 13137 0ustar downsjuser/* gdbmsync.c - Sync the disk with the in memory state. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" /* Make sure the database is all on disk. */ void gdbm_sync (dbf) gdbm_file_info *dbf; { /* Initialize the gdbm_errno variable. */ gdbm_errno = GDBM_NO_ERROR; /* Do the sync on the file. */ fsync (dbf->desc); } gdbm-1.7.2/gdbmerrno.c100600 24413 24 4157 5507304506 13317 0ustar downsjuser/* gdbmerrno.c - convert gdbm errors into english. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the original author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 The author of this file is: e-mail: downsj@csos.orst.edu *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmerrno.h" /* this is not static so that applications may access the array if they like. it must be in the same order as the error codes! */ const char * const gdbm_errlist[] = { "No error", "Malloc error", "Block size error", "File open error", "File write error", "File seek error", "File read error", "Bad magic number", "Empty database", "Can't be reader", "Can't be writer", "Reader can't delete", "Reader can't store", "Reader can't reorganize", "Unknown update", "Item not found", "Reorganize failed", "Cannot replace", "Illegal data", "Option already set", "Illegal option" }; const char * gdbm_strerror(error) gdbm_error error; { if(((int)error < 0) || ((int)error > 18)) { return("Unkown error"); } else { return(gdbm_errlist[(int)error]); } } gdbm-1.7.2/bucket.c100600 24413 24 26500 5541040264 12625 0ustar downsjuser/* bucket.c - The routines for playing with hash buckets. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" /* Initializing a new hash buckets sets all bucket entries to -1 hash value. */ void _gdbm_new_bucket (dbf, bucket, bits) gdbm_file_info *dbf; hash_bucket *bucket; int bits; { int index; /* Initialize the avail block. */ bucket->av_count = 0; /* Set the information fields first. */ bucket->bucket_bits = bits; bucket->count = 0; /* Initialize all bucket elements. */ for (index = 0; index < dbf->header->bucket_elems; index++) bucket->h_table[index].hash_value = -1; } /* Find a bucket for DBF that is pointed to by the bucket directory from location DIR_INDEX. The bucket cache is first checked to see if it is already in memory. If not, a bucket may be tossed to read the new bucket. In any case, the requested bucket is make the "current" bucket and dbf->bucket points to the correct bucket. */ void _gdbm_get_bucket (dbf, dir_index) gdbm_file_info *dbf; word_t dir_index; { off_t bucket_adr; /* The address of the correct hash bucket. */ int num_bytes; /* The number of bytes read. */ off_t file_pos; /* The return address for lseek. */ register int index; /* Loop index. */ /* Initial set up. */ dbf->bucket_dir = dir_index; bucket_adr = dbf->dir [dir_index]; if (dbf->bucket_cache == NULL) { if(_gdbm_init_cache(dbf, DEFAULT_CACHESIZE) == -1) _gdbm_fatal(dbf, "couldn't init cache"); } /* Is that one is not already current, we must find it. */ if (dbf->cache_entry->ca_adr != bucket_adr) { /* Look in the cache. */ for (index = 0; index < dbf->cache_size; index++) { if (dbf->bucket_cache[index].ca_adr == bucket_adr) { dbf->bucket = dbf->bucket_cache[index].ca_bucket; dbf->cache_entry = &dbf->bucket_cache[index]; return; } } /* It is not in the cache, read it from the disk. */ dbf->last_read = (dbf->last_read + 1) % dbf->cache_size; if (dbf->bucket_cache[dbf->last_read].ca_changed) _gdbm_write_bucket (dbf, &dbf->bucket_cache[dbf->last_read]); dbf->bucket_cache[dbf->last_read].ca_adr = bucket_adr; dbf->bucket = dbf->bucket_cache[dbf->last_read].ca_bucket; dbf->cache_entry = &dbf->bucket_cache[dbf->last_read]; dbf->cache_entry->ca_data.elem_loc = -1; dbf->cache_entry->ca_changed = FALSE; /* Read the bucket. */ file_pos = lseek (dbf->desc, bucket_adr, L_SET); if (file_pos != bucket_adr) _gdbm_fatal (dbf, "lseek error"); num_bytes = read (dbf->desc, dbf->bucket, dbf->header->bucket_size); if (num_bytes != dbf->header->bucket_size) _gdbm_fatal (dbf, "read error"); } return; } /* Split the current bucket. This includes moving all items in the bucket to a new bucket. This doesn't require any disk reads because all hash values are stored in the buckets. Splitting the current bucket may require doubling the size of the hash directory. */ void _gdbm_split_bucket (dbf, next_insert) gdbm_file_info *dbf; word_t next_insert; { hash_bucket *bucket[2]; /* Pointers to the new buckets. */ int new_bits; /* The number of bits for the new buckets. */ int cache_0; /* Location in the cache for the buckets. */ int cache_1; off_t adr_0; /* File address of the new bucket 0. */ off_t adr_1; /* File address of the new bucket 1. */ avail_elem old_bucket; /* Avail Struct for the old bucket. */ off_t dir_start0; /* Used in updating the directory. */ off_t dir_start1; off_t dir_end; off_t *new_dir; /* Pointer to the new directory. */ off_t dir_adr; /* Address of the new directory. */ int dir_size; /* Size of the new directory. */ off_t old_adr[31]; /* Address of the old directories. */ int old_size[31]; /* Size of the old directories. */ int old_count; /* Number of old directories. */ int index; /* Used in array indexing. */ int index1; /* Used in array indexing. */ int elem_loc; /* Location in new bucket to put element. */ bucket_element *old_el; /* Pointer into the old bucket. */ int select; /* Used to index bucket during movement. */ /* No directories are yet old. */ old_count = 0; if (dbf->bucket_cache == NULL) { if(_gdbm_init_cache(dbf, DEFAULT_CACHESIZE) == -1) _gdbm_fatal(dbf, "couldn't init cache"); } while (dbf->bucket->count == dbf->header->bucket_elems) { /* Initialize the "new" buckets in the cache. */ do { dbf->last_read = (dbf->last_read + 1) % dbf->cache_size; cache_0 = dbf->last_read; } while (dbf->bucket_cache[cache_0].ca_bucket == dbf->bucket); bucket[0] = dbf->bucket_cache[cache_0].ca_bucket; if (dbf->bucket_cache[cache_0].ca_changed) _gdbm_write_bucket (dbf, &dbf->bucket_cache[cache_0]); do { dbf->last_read = (dbf->last_read + 1) % dbf->cache_size; cache_1 = dbf->last_read; } while (dbf->bucket_cache[cache_1].ca_bucket == dbf->bucket); bucket[1] = dbf->bucket_cache[cache_1].ca_bucket; if (dbf->bucket_cache[cache_1].ca_changed) _gdbm_write_bucket (dbf, &dbf->bucket_cache[cache_1]); new_bits = dbf->bucket->bucket_bits+1; _gdbm_new_bucket (dbf, bucket[0], new_bits); _gdbm_new_bucket (dbf, bucket[1], new_bits); adr_0 = _gdbm_alloc (dbf, dbf->header->bucket_size); dbf->bucket_cache[cache_0].ca_adr = adr_0; adr_1 = _gdbm_alloc (dbf, dbf->header->bucket_size); dbf->bucket_cache[cache_1].ca_adr = adr_1; /* Double the directory size if necessary. */ if (dbf->header->dir_bits == dbf->bucket->bucket_bits) { dir_size = dbf->header->dir_size * 2; dir_adr = _gdbm_alloc (dbf, dir_size); new_dir = (off_t *) malloc (dir_size); if (new_dir == NULL) _gdbm_fatal (dbf, "malloc error"); for (index = 0; index < dbf->header->dir_size/sizeof (off_t); index++) { new_dir[2*index] = dbf->dir[index]; new_dir[2*index+1] = dbf->dir[index]; } /* Update header. */ old_adr[old_count] = dbf->header->dir; dbf->header->dir = dir_adr; old_size[old_count] = dbf->header->dir_size; dbf->header->dir_size = dir_size; dbf->header->dir_bits = new_bits; old_count++; /* Now update dbf. */ dbf->header_changed = TRUE; dbf->bucket_dir *= 2; free (dbf->dir); dbf->dir = new_dir; } /* Copy all elements in dbf->bucket into the new buckets. */ for (index = 0; index < dbf->header->bucket_elems; index++) { old_el = & (dbf->bucket->h_table[index]); select = (old_el->hash_value >> (31-new_bits)) & 1; elem_loc = old_el->hash_value % dbf->header->bucket_elems; while (bucket[select]->h_table[elem_loc].hash_value != -1) elem_loc = (elem_loc + 1) % dbf->header->bucket_elems; bucket[select]->h_table[elem_loc] = *old_el; bucket[select]->count += 1; } /* Allocate avail space for the bucket[1]. */ bucket[1]->bucket_avail[0].av_adr = _gdbm_alloc (dbf, dbf->header->block_size); bucket[1]->bucket_avail[0].av_size = dbf->header->block_size; bucket[1]->av_count = 1; /* Copy the avail elements in dbf->bucket to bucket[0]. */ bucket[0]->av_count = dbf->bucket->av_count; index = 0; index1 = 0; if (bucket[0]->av_count == BUCKET_AVAIL) { /* The avail is full, move the first one to bucket[1]. */ _gdbm_put_av_elem (dbf->bucket->bucket_avail[0], bucket[1]->bucket_avail, &bucket[1]->av_count); index = 1; bucket[0]->av_count --; } for (; index < dbf->bucket->av_count; index++) { bucket[0]->bucket_avail[index1++] = dbf->bucket->bucket_avail[index]; } /* Update the directory. We have new file addresses for both buckets. */ dir_start1 = (dbf->bucket_dir >> (dbf->header->dir_bits - new_bits)) | 1; dir_end = (dir_start1 + 1) << (dbf->header->dir_bits - new_bits); dir_start1 = dir_start1 << (dbf->header->dir_bits - new_bits); dir_start0 = dir_start1 - (dir_end - dir_start1); for (index = dir_start0; index < dir_start1; index++) dbf->dir[index] = adr_0; for (index = dir_start1; index < dir_end; index++) dbf->dir[index] = adr_1; /* Set changed flags. */ dbf->bucket_cache[cache_0].ca_changed = TRUE; dbf->bucket_cache[cache_1].ca_changed = TRUE; dbf->bucket_changed = TRUE; dbf->directory_changed = TRUE; dbf->second_changed = TRUE; /* Update the cache! */ dbf->bucket_dir = next_insert >> (31-dbf->header->dir_bits); /* Invalidate old cache entry. */ old_bucket.av_adr = dbf->cache_entry->ca_adr; old_bucket.av_size = dbf->header->bucket_size; dbf->cache_entry->ca_adr = 0; dbf->cache_entry->ca_changed = FALSE; /* Set dbf->bucket to the proper bucket. */ if (dbf->dir[dbf->bucket_dir] == adr_0) { dbf->bucket = bucket[0]; dbf->cache_entry = &dbf->bucket_cache[cache_0]; _gdbm_put_av_elem (old_bucket, bucket[1]->bucket_avail, &bucket[1]->av_count); } else { dbf->bucket = bucket[1]; dbf->cache_entry = &dbf->bucket_cache[cache_1]; _gdbm_put_av_elem (old_bucket, bucket[0]->bucket_avail, &bucket[0]->av_count); } } /* Get rid of old directories. */ for (index = 0; index < old_count; index++) _gdbm_free (dbf, old_adr[index], old_size[index]); } /* The only place where a bucket is written. CA_ENTRY is the cache entry containing the bucket to be written. */ void _gdbm_write_bucket (dbf, ca_entry) gdbm_file_info *dbf; cache_elem *ca_entry; { int num_bytes; /* The return value for write. */ off_t file_pos; /* The return value for lseek. */ file_pos = lseek (dbf->desc, ca_entry->ca_adr, L_SET); if (file_pos != ca_entry->ca_adr) _gdbm_fatal (dbf, "lseek error"); num_bytes = write (dbf->desc, ca_entry->ca_bucket, dbf->header->bucket_size); if (num_bytes != dbf->header->bucket_size) _gdbm_fatal (dbf, "write error"); ca_entry->ca_changed = FALSE; ca_entry->ca_data.hash_val = -1; ca_entry->ca_data.elem_loc = -1; } gdbm-1.7.2/gdbmexists.c100600 24413 24 3232 5507304533 13502 0ustar downsjuser/* gdbmexists.c - Check to see if a key exists */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the original author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 The author of this file is: e-mail: downsj@csos.orst.edu *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" /* this is nothing more than a wrapper around _gdbm_findkey(). the point? it doesn't alloate any memory. */ int gdbm_exists (dbf, key) gdbm_file_info *dbf; datum key; { char *find_data; /* dummy */ word_t hash_val; /* dummy */ return (_gdbm_findkey (dbf, key, &find_data, &hash_val) >= 0); } gdbm-1.7.2/gdbmsetopt.c100600 24413 24 4464 5541030431 13500 0ustar downsjuser/* gdbmsetopt.c - set options pertaining to a GDBM descriptor. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1993, 1994 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the original author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 The author of this file is: e-mail: downsj@csos.orst.edu *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" /* operate on an already open descriptor. */ /* ARGSUSED */ int gdbm_setopt(dbf, optflag, optval, optlen) gdbm_file_info *dbf; /* descriptor to operate on. */ int optflag; /* option to set. */ int *optval; /* pointer to option value. */ int optlen; /* size of optval. */ { switch(optflag) { case GDBM_CACHESIZE: /* here, optval will point to the new size of the cache. */ if (dbf->bucket_cache != NULL) { gdbm_errno = GDBM_OPT_ALREADY_SET; return(-1); } return(_gdbm_init_cache(dbf, ((*optval) > 9) ? (*optval) : 10)); case GDBM_FASTMODE: /* here, optval will point to either true or false. */ if ((*optval != TRUE) && (*optval != FALSE)) { gdbm_errno = GDBM_OPT_ILLEGAL; return(-1); } dbf->fast_write = *optval; break; default: gdbm_errno = GDBM_OPT_ILLEGAL; return(-1); } return(0); } gdbm-1.7.2/falloc.c100600 24413 24 27651 5543002311 12611 0ustar downsjuser/* falloc.c - The file space management routines for dbm. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993, 1994 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" /* The forward definitions for this file. See the functions for the definition of the function. */ static avail_elem get_elem _ARGS((int, avail_elem [], int *)); static avail_elem get_block _ARGS((int, gdbm_file_info *)); static void push_avail_block _ARGS((gdbm_file_info *)); static void pop_avail_block _ARGS((gdbm_file_info *)); static void adjust_bucket_avail _ARGS((gdbm_file_info *)); /* Allocate space in the file DBF for a block NUM_BYTES in length. Return the file address of the start of the block. Each hash bucket has a fixed size avail table. We first check this avail table to satisfy the request for space. In most cases we can and this causes changes to be only in the current hash bucket. Allocation is done on a first fit basis from the entries. If a request can not be satisfied from the current hash bucket, then it is satisfied from the file header avail block. If nothing is there that has enough space, another block at the end of the file is allocated and the unused portion is returned to the avail block. This routine "guarantees" that an allocation does not cross a block boundary unless the size is larger than a single block. The avail structure is changed by this routine if a change is needed. If an error occurs, the value of 0 will be returned. */ off_t _gdbm_alloc (dbf, num_bytes) gdbm_file_info *dbf; int num_bytes; { off_t file_adr; /* The address of the block. */ avail_elem av_el; /* For temporary use. */ /* The current bucket is the first place to look for space. */ av_el = get_elem (num_bytes, dbf->bucket->bucket_avail, &dbf->bucket->av_count); /* If we did not find some space, we have more work to do. */ if (av_el.av_size == 0) { /* Is the header avail block empty and there is something on the stack. */ if ((dbf->header->avail.count == 0) && (dbf->header->avail.next_block != 0)) pop_avail_block (dbf); /* check the header avail table next */ av_el = get_elem (num_bytes, dbf->header->avail.av_table, &dbf->header->avail.count); if (av_el.av_size == 0) /* Get another full block from end of file. */ av_el = get_block (num_bytes, dbf); dbf->header_changed = TRUE; } /* We now have the place from which we will allocate the new space. */ file_adr = av_el.av_adr; /* Put the unused space back in the avail block. */ av_el.av_adr += num_bytes; av_el.av_size -= num_bytes; _gdbm_free (dbf, av_el.av_adr, av_el.av_size); /* Return the address. */ return file_adr; } /* Free space of size NUM_BYTES in the file DBF at file address FILE_ADR. Make it avaliable for reuse through _gdbm_alloc. This routine changes the avail structure. The value TRUE is returned if there were errors. If no errors occured, the value FALSE is returned. */ void _gdbm_free (dbf, file_adr, num_bytes) gdbm_file_info *dbf; off_t file_adr; int num_bytes; { avail_elem temp; /* Is it too small to worry about? */ if (num_bytes <= IGNORE_SIZE) return; /* Initialize the avail element. */ temp.av_size = num_bytes; temp.av_adr = file_adr; /* Is the freed space large or small? */ if (num_bytes >= dbf->header->block_size) { if (dbf->header->avail.count == dbf->header->avail.size) { push_avail_block (dbf); } _gdbm_put_av_elem (temp, dbf->header->avail.av_table, &dbf->header->avail.count); dbf->header_changed = TRUE; } else { /* Try to put into the current bucket. */ if (dbf->bucket->av_count < BUCKET_AVAIL) _gdbm_put_av_elem (temp, dbf->bucket->bucket_avail, &dbf->bucket->av_count); else { if (dbf->header->avail.count == dbf->header->avail.size) { push_avail_block (dbf); } _gdbm_put_av_elem (temp, dbf->header->avail.av_table, &dbf->header->avail.count); dbf->header_changed = TRUE; } } if (dbf->header_changed) adjust_bucket_avail (dbf); /* All work is done. */ return; } /* The following are all utility routines needed by the previous two. */ /* Gets the avail block at the top of the stack and loads it into the active avail block. It does a "free" for itself! */ static void pop_avail_block (dbf) gdbm_file_info *dbf; { int num_bytes; /* For use with the read system call. */ off_t file_pos; /* For use with the lseek system call. */ avail_elem temp; /* Set up variables. */ temp.av_adr = dbf->header->avail.next_block; temp.av_size = ( ( (dbf->header->avail.size * sizeof (avail_elem)) >> 1) + sizeof (avail_block)); /* Read the block. */ file_pos = lseek (dbf->desc, temp.av_adr, L_SET); if (file_pos != temp.av_adr) _gdbm_fatal (dbf, "lseek error"); num_bytes = read (dbf->desc, &dbf->header->avail, temp.av_size); if (num_bytes != temp.av_size) _gdbm_fatal (dbf, "read error"); /* We changed the header. */ dbf->header_changed = TRUE; /* Free the previous avail block. */ _gdbm_put_av_elem (temp, dbf->header->avail.av_table, &dbf->header->avail.count); } /* Splits the header avail block and pushes half onto the avail stack. */ static void push_avail_block (dbf) gdbm_file_info *dbf; { int num_bytes; int av_size; off_t av_adr; int index; off_t file_pos; avail_block *temp; avail_elem new_loc; /* Caclulate the size of the split block. */ av_size = ( (dbf->header->avail.size * sizeof (avail_elem)) >> 1) + sizeof (avail_block); /* Get address in file for new av_size bytes. */ new_loc = get_elem (av_size, dbf->header->avail.av_table, &dbf->header->avail.count); if (new_loc.av_size == 0) new_loc = get_block (av_size, dbf); av_adr = new_loc.av_adr; /* Split the header block. */ temp = (avail_block *) alloca (av_size); /* Set the size to be correct AFTER the pop_avail_block. */ temp->size = dbf->header->avail.size; temp->count = 0; temp->next_block = dbf->header->avail.next_block; dbf->header->avail.next_block = av_adr; for (index = 1; index < dbf->header->avail.count; index++) if ( (index & 0x1) == 1) /* Index is odd. */ temp->av_table[temp->count++] = dbf->header->avail.av_table[index]; else dbf->header->avail.av_table[index>>1] = dbf->header->avail.av_table[index]; /* Update the header avail count to previous size divided by 2. */ dbf->header->avail.count >>= 1; /* Free the unneeded space. */ new_loc.av_adr += av_size; new_loc.av_size -= av_size; _gdbm_free (dbf, new_loc.av_adr, new_loc.av_size); /* Update the disk. */ file_pos = lseek (dbf->desc, av_adr, L_SET); if (file_pos != av_adr) _gdbm_fatal (dbf, "lseek error"); num_bytes = write (dbf->desc, temp, av_size); if (num_bytes != av_size) _gdbm_fatal (dbf, "write error"); } /* Get_elem returns an element in the AV_TABLE block which is larger than SIZE. AV_COUNT is the number of elements in the AV_TABLE. If an item is found, it extracts it from the AV_TABLE and moves the other elements up to fill the space. If no block is found larger than SIZE, get_elem returns a size of zero. This routine does no I/O. */ static avail_elem get_elem (size, av_table, av_count) int size; avail_elem av_table[]; int *av_count; { int index; /* For searching through the avail block. */ avail_elem val; /* The default return value. */ /* Initialize default return value. */ val.av_adr = 0; val.av_size = 0; /* Search for element. List is sorted by size. */ index = 0; while (index < *av_count && av_table[index].av_size < size) { index++; } /* Did we find one of the right size? */ if (index >= *av_count) return val; /* Ok, save that element and move all others up one. */ val = av_table[index]; *av_count -= 1; while (index < *av_count) { av_table[index] = av_table[index+1]; index++; } return val; } /* This routine inserts a single NEW_EL into the AV_TABLE block in sorted order. This routine does no I/O. */ int _gdbm_put_av_elem (new_el, av_table, av_count) avail_elem new_el; avail_elem av_table[]; int *av_count; { int index; /* For searching through the avail block. */ int index1; /* Is it too small to deal with? */ if (new_el.av_size <= IGNORE_SIZE) return FALSE; /* Search for place to put element. List is sorted by size. */ index = 0; while (index < *av_count && av_table[index].av_size < new_el.av_size) { index++; } /* Move all others up one. */ index1 = *av_count-1; while (index1 >= index) { av_table[index1+1] = av_table[index1]; index1--; } /* Add the new element. */ av_table[index] = new_el; /* Increment the number of elements. */ *av_count += 1; return TRUE; } /* Get_block "allocates" new file space and the end of the file. This is done in integral block sizes. (This helps insure that data smaller than one block size is in a single block.) Enough blocks are allocated to make sure the number of bytes allocated in the blocks is larger than SIZE. DBF contains the file header that needs updating. This routine does no I/O. */ static avail_elem get_block (size, dbf) int size; gdbm_file_info *dbf; { avail_elem val; /* Need at least one block. */ val.av_adr = dbf->header->next_block; val.av_size = dbf->header->block_size; /* Get enough blocks to fit the need. */ while (val.av_size < size) val.av_size += dbf->header->block_size; /* Update the header and return. */ dbf->header->next_block += val.av_size; /* We changed the header. */ dbf->header_changed = TRUE; return val; } /* When the header already needs writing, we can make sure the current bucket has its avail block as close to 1/2 full as possible. */ static void adjust_bucket_avail (dbf) gdbm_file_info *dbf; { int third = BUCKET_AVAIL / 3; avail_elem av_el; /* Can we add more entries to the bucket? */ if (dbf->bucket->av_count < third) { if (dbf->header->avail.count > 0) { dbf->header->avail.count -= 1; av_el = dbf->header->avail.av_table[dbf->header->avail.count]; _gdbm_put_av_elem (av_el, dbf->bucket->bucket_avail, &dbf->bucket->av_count); dbf->bucket_changed = TRUE; } return; } /* Is there too much in the bucket? */ while (dbf->bucket->av_count > BUCKET_AVAIL-third && dbf->header->avail.count < dbf->header->avail.size) { av_el = get_elem (0, dbf->bucket->bucket_avail, &dbf->bucket->av_count); _gdbm_put_av_elem (av_el, dbf->header->avail.av_table, &dbf->header->avail.count); dbf->bucket_changed = TRUE; } } gdbm-1.7.2/findkey.c100600 24413 24 13012 5507304376 13004 0ustar downsjuser/* findkey.c - The routine that finds a key entry in the file. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" /* Read the data found in bucket entry ELEM_LOC in file DBF and return a pointer to it. Also, cache the read value. */ char * _gdbm_read_entry (dbf, elem_loc) gdbm_file_info *dbf; int elem_loc; { int num_bytes; /* For seeking and reading. */ int key_size; int data_size; off_t file_pos; data_cache_elem *data_ca; /* Is it already in the cache? */ if (dbf->cache_entry->ca_data.elem_loc == elem_loc) return dbf->cache_entry->ca_data.dptr; /* Set sizes and pointers. */ key_size = dbf->bucket->h_table[elem_loc].key_size; data_size = dbf->bucket->h_table[elem_loc].data_size; data_ca = &dbf->cache_entry->ca_data; /* Set up the cache. */ if (data_ca->dptr != NULL) free (data_ca->dptr); data_ca->key_size = key_size; data_ca->data_size = data_size; data_ca->elem_loc = elem_loc; data_ca->hash_val = dbf->bucket->h_table[elem_loc].hash_value; if (key_size+data_size == 0) data_ca->dptr = (char *) malloc (1); else data_ca->dptr = (char *) malloc (key_size+data_size); if (data_ca->dptr == NULL) _gdbm_fatal (dbf, "malloc error"); /* Read into the cache. */ file_pos = lseek (dbf->desc, dbf->bucket->h_table[elem_loc].data_pointer, L_SET); if (file_pos != dbf->bucket->h_table[elem_loc].data_pointer) _gdbm_fatal (dbf, "lseek error"); num_bytes = read (dbf->desc, data_ca->dptr, key_size+data_size); if (num_bytes != key_size+data_size) _gdbm_fatal (dbf, "read error"); return data_ca->dptr; } /* Find the KEY in the file and get ready to read the associated data. The return value is the location in the current hash bucket of the KEY's entry. If it is found, a pointer to the data and the key are returned in DPTR. If it is not found, the value -1 is returned. Since find key computes the hash value of key, that value */ int _gdbm_findkey (dbf, key, dptr, new_hash_val) gdbm_file_info *dbf; datum key; char **dptr; word_t *new_hash_val; /* The new hash value. */ { word_t bucket_hash_val; /* The hash value from the bucket. */ char *file_key; /* The complete key as stored in the file. */ int elem_loc; /* The location in the bucket. */ int home_loc; /* The home location in the bucket. */ int key_size; /* Size of the key on the file. */ /* Compute hash value and load proper bucket. */ *new_hash_val = _gdbm_hash (key); _gdbm_get_bucket (dbf, *new_hash_val>> (31-dbf->header->dir_bits)); /* Is the element the last one found for this bucket? */ if (dbf->cache_entry->ca_data.elem_loc != -1 && *new_hash_val == dbf->cache_entry->ca_data.hash_val && dbf->cache_entry->ca_data.key_size == key.dsize && dbf->cache_entry->ca_data.dptr != NULL && bcmp (dbf->cache_entry->ca_data.dptr, key.dptr, key.dsize) == 0) { /* This is it. Return the cache pointer. */ *dptr = dbf->cache_entry->ca_data.dptr+key.dsize; return dbf->cache_entry->ca_data.elem_loc; } /* It is not the cached value, search for element in the bucket. */ elem_loc = *new_hash_val % dbf->header->bucket_elems; home_loc = elem_loc; bucket_hash_val = dbf->bucket->h_table[elem_loc].hash_value; while (bucket_hash_val != -1) { key_size = dbf->bucket->h_table[elem_loc].key_size; if (bucket_hash_val != *new_hash_val || key_size != key.dsize || bcmp (dbf->bucket->h_table[elem_loc].key_start, key.dptr, (SMALL < key_size ? SMALL : key_size)) != 0) { /* Current elem_loc is not the item, go to next item. */ elem_loc = (elem_loc + 1) % dbf->header->bucket_elems; if (elem_loc == home_loc) return -1; bucket_hash_val = dbf->bucket->h_table[elem_loc].hash_value; } else { /* This may be the one we want. The only way to tell is to read it. */ file_key = _gdbm_read_entry (dbf, elem_loc); if (bcmp (file_key, key.dptr, key_size) == 0) { /* This is the item. */ *dptr = file_key+key.dsize; return elem_loc; } else { /* Not the item, try the next one. Return if not found. */ elem_loc = (elem_loc + 1) % dbf->header->bucket_elems; if (elem_loc == home_loc) return -1; bucket_hash_val = dbf->bucket->h_table[elem_loc].hash_value; } } } /* If we get here, we never found the key. */ return -1; } gdbm-1.7.2/global.c100600 24413 24 3316 5471123553 12575 0ustar downsjuser/* global.c - The external variables needed for "original" interface and error messages. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" /* The global variables used for the "original" interface. */ gdbm_file_info *_gdbm_file = NULL; /* Memory for return data for the "original" interface. */ datum _gdbm_memory = {NULL, 0}; /* Used by firstkey and nextkey. */ char *_gdbm_fetch_val = NULL; /* Used by fetch. */ /* The dbm error number is placed in the variable GDBM_ERRNO. */ gdbm_error gdbm_errno = GDBM_NO_ERROR; gdbm-1.7.2/hash.c100600 24413 24 4103 5471123570 12252 0ustar downsjuser/* hash.c - The gdbm hash function. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" /* This hash function computes a 31 bit value. The value is used to index the hash directory using the top n bits. It is also used in a hash bucket to find the home position of the element by taking the value modulo the bucket hash table size. */ word_t _gdbm_hash (key) datum key; { #if LONG_64_BITS || !INT_16_BITS unsigned int value; /* Used to compute the hash value. */ #else unsigned long value; /* Used to compute the hash value. */ #endif int index; /* Used to cycle through random values. */ /* Set the initial value from key. */ value = 0x238F13AF * key.dsize; for (index = 0; index < key.dsize; index++) value = (value + (key.dptr[index] << (index*5 % 24))) & 0x7FFFFFFF; value = (1103515243 * value + 12345) & 0x7FFFFFFF; /* Return the value. */ return((word_t) value); } gdbm-1.7.2/update.c100600 24413 24 7175 5507306746 12635 0ustar downsjuser/* update.c - The routines for updating the file to a consistent state. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" static void write_header _ARGS((gdbm_file_info *)); /* This procedure writes the header back to the file described by DBF. */ static void write_header (dbf) gdbm_file_info *dbf; { int num_bytes; /* Return value for write. */ off_t file_pos; /* Return value for lseek. */ file_pos = lseek (dbf->desc, 0L, L_SET); if (file_pos != 0) _gdbm_fatal (dbf, "lseek error"); num_bytes = write (dbf->desc, dbf->header, dbf->header->block_size); if (num_bytes != dbf->header->block_size) _gdbm_fatal (dbf, "write error"); /* Wait for all output to be done. */ if (!dbf->fast_write) fsync (dbf->desc); } /* After all changes have been made in memory, we now write them all to disk. */ void _gdbm_end_update (dbf) gdbm_file_info *dbf; { int num_bytes; /* Return value for write. */ off_t file_pos; /* Return value for lseek. */ /* Write the current bucket. */ if (dbf->bucket_changed && (dbf->cache_entry != NULL)) { _gdbm_write_bucket (dbf, dbf->cache_entry); dbf->bucket_changed = FALSE; } /* Write the other changed buckets if there are any. */ if (dbf->second_changed) { if(dbf->bucket_cache != NULL) { register int index; for (index = 0; index < dbf->cache_size; index++) { if (dbf->bucket_cache[index].ca_changed) _gdbm_write_bucket (dbf, &dbf->bucket_cache[index]); } } dbf->second_changed = FALSE; } /* Write the directory. */ if (dbf->directory_changed) { file_pos = lseek (dbf->desc, dbf->header->dir, L_SET); if (file_pos != dbf->header->dir) _gdbm_fatal (dbf, "lseek error"); num_bytes = write (dbf->desc, dbf->dir, dbf->header->dir_size); if (num_bytes != dbf->header->dir_size) _gdbm_fatal (dbf, "write error"); dbf->directory_changed = FALSE; if (!dbf->header_changed && !dbf->fast_write) fsync (dbf->desc); } /* Final write of the header. */ if (dbf->header_changed) { write_header (dbf); dbf->header_changed = FALSE; } } /* If a fatal error is detected, come here and exit. VAL tells which fatal error occured. */ int _gdbm_fatal (dbf, val) gdbm_file_info *dbf; char *val; { if (dbf->fatal_err != NULL) (*dbf->fatal_err) (val); else fprintf (stderr, "gdbm fatal: %s.\n", val); exit (-1); /* NOTREACHED */ } gdbm-1.7.2/version.c100600 24413 24 2505 5565361330 13022 0ustar downsjuser/* version.c - This is file contains the version number for gdbm source. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* Keep a string with the version number in it! */ const char * gdbm_version = "This is GDBM version 1.7.2, as of May 15, 1994."; gdbm-1.7.2/testdbm.c100600 24413 24 11470 5507306103 13011 0ustar downsjuser/* testdbm.c - Driver program to test the dbm interface routines. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include #include #if HAVE_SYS_FILE_H #include #endif #include #define TRUE 1 #define FALSE 0 typedef struct { char *dptr; int dsize; } datum; extern datum fetch (); extern datum firstkey (); extern datum nextkey (); /* The test program allows one to call all the routines plus the hash function. The commands are single letter commands. The user is prompted for all other information. The commands are q (quit), f (fetch), s (store), d (delete), 1 (firstkey), n (nextkey) and h (hash function). */ int main (argc, argv) int argc; char *argv[]; { char cmd_ch; datum key_data; datum data_data; datum return_data; char key_line[500]; char data_line[1000]; char done = FALSE; char sys[255]; char *file_name; /* Argument checking. */ if (argc > 2) { printf ("Usage: %s [dbm-file] \n",argv[0]); exit (2); } if (argc > 1) { file_name = argv[1]; } else { file_name = "junkdbm"; } /* Initialize */ data_data.dptr = data_line; if (dbminit (file_name) != 0) { sprintf (sys,"touch %s.pag %s.dir", file_name, file_name); system (sys); if (dbminit (file_name) != 0) { printf ("dbminit failed.\n"); exit (2); } } /* Welcome message. */ printf ("\nWelcome to the dbm test program. Type ? for help.\n\n"); while (!done) { printf ("com -> "); cmd_ch = getchar (); while (getchar () != '\n') /* Do nothing. */; switch (cmd_ch) { case 'q': done = TRUE; break; case 'f': printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; return_data = fetch (key_data); if (return_data.dptr != NULL) printf ("data is ->%s\n\n", return_data.dptr); else printf ("No such item found.\n\n"); break; case 's': printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; printf ("data -> "); gets (data_line); data_data.dsize = strlen (data_line)+1; if (store (key_data, data_data) != 0) printf ("Item not inserted. \n"); printf ("\n"); break; case 'd': printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; if (delete (key_data) != 0) printf ("Item not found or deleted\n"); printf ("\n"); break; case '1': key_data = firstkey (); if (key_data.dptr != NULL) { return_data = fetch (key_data); printf ("key is ->%s\n", key_data.dptr); printf ("data is ->%s\n\n", return_data.dptr); } else printf ("No such item found.\n\n"); break; case '2': key_data = nextkey (key_data); if (key_data.dptr != NULL) { return_data = fetch (key_data); printf ("key is ->%s\n", key_data.dptr); printf ("data is ->%s\n\n", return_data.dptr); } else printf ("No such item found.\n\n"); break; case 'c': { int temp; temp = 0; return_data = firstkey (); while (return_data.dptr != NULL) { temp++; return_data = nextkey (return_data); } printf ("There are %d items in the database.\n\n", temp); } break; case '?': printf ("c - count elements\n"); printf ("d - delete\n"); printf ("f - fetch\n"); printf ("q - quit\n"); printf ("s - store\n"); printf ("1 - firstkey\n"); printf ("2 - nextkey on last return value\n\n"); break; default: printf ("What? \n\n"); break; } } /* Quit normally. */ exit (0); } gdbm-1.7.2/testndbm.c100600 24413 24 11540 5507306475 13201 0ustar downsjuser/* testndbm.c - Driver program to test the ndbm interface routines. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include #include #if HAVE_FILE_H #include #endif #include #if HAVE_FCNTL_H #include #endif #ifdef GNU #include "ndbm.h" #else #include #endif #define TRUE 1 #define FALSE 0 /* The test program allows one to call all the routines plus the hash function. The commands are single letter commands. The user is prompted for all other information. The commands are q (quit), f (fetch), s (store), d (delete), 1 (firstkey), n (nextkey) and h (hash function). */ int main (argc, argv) int argc; char *argv[]; { char cmd_ch; datum key_data; datum data_data; datum return_data; char key_line[500]; char data_line[1000]; DBM *dbm_file; char done = FALSE; char *file_name; /* Argument checking. */ if (argc > 2) { printf ("Usage: %s [dbm-file] \n",argv[0]); exit (2); } if (argc > 1) { file_name = argv[1]; } else { file_name = "junkndbm"; } /* Initialize. */ data_data.dptr = data_line; dbm_file = dbm_open (file_name, O_RDWR|O_CREAT, 00664); if (dbm_file == NULL) { printf ("dbm_open failed.\n"); exit (2); } /* Welcome message. */ printf ("\nWelcome to the gndbm test program. Type ? for help.\n\n"); while (!done) { printf ("com -> "); cmd_ch = getchar (); while (getchar () != '\n') /* Do nothing. */; switch (cmd_ch) { case 'q': done = TRUE; break; case 'f': printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; return_data = dbm_fetch (dbm_file, key_data); if (return_data.dptr != NULL) printf ("data is ->%s\n\n", return_data.dptr); else printf ("No such item found.\n\n"); break; case 's': printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; printf ("data -> "); gets (data_line); data_data.dsize = strlen (data_line)+1; if (dbm_store (dbm_file, key_data, data_data, DBM_REPLACE) != 0) printf ("Item not inserted. \n"); printf ("\n"); break; case 'd': printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; if (dbm_delete (dbm_file, key_data) != 0) printf ("Item not found or deleted\n"); printf ("\n"); break; case '1': key_data = dbm_firstkey (dbm_file); if (key_data.dptr != NULL) { return_data = dbm_fetch (dbm_file, key_data); printf ("key is ->%s\n", key_data.dptr); printf ("data is ->%s\n\n", return_data.dptr); } else printf ("No such item found.\n\n"); break; case '2': key_data = dbm_nextkey (dbm_file); if (key_data.dptr != NULL) { return_data = dbm_fetch (dbm_file, key_data); printf ("key is ->%s\n", key_data.dptr); printf ("data is ->%s\n\n", return_data.dptr); } else printf ("No such item found.\n\n"); break; case 'c': { int temp; temp = 0; return_data = dbm_firstkey (dbm_file); while (return_data.dptr != NULL) { temp++; return_data = dbm_nextkey (dbm_file); } printf ("There are %d items in the database.\n\n", temp); } break; case '?': printf ("c - count elements\n"); printf ("d - delete\n"); printf ("f - fetch\n"); printf ("q - quit\n"); printf ("s - store\n"); printf ("1 - firstkey\n"); printf ("2 - nextkey on last return value\n\n"); break; default: printf ("What? \n\n"); break; } } /* Quit normally. */ dbm_close (dbm_file); exit (0); } gdbm-1.7.2/testgdbm.c100600 24413 24 32326 5507306434 13172 0ustar downsjuser/* testgdbm.c - Driver program to test the database routines and to help debug gdbm. Uses inside information to show "system" information */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* AIX demands this be the very first thing in the file. */ #if !defined(__GNUC__) && defined(_AIX) #pragma alloca #endif /* include system configuration before all else. */ #include "autoconf.h" #include "gdbmdefs.h" #include "gdbmerrno.h" #include "extern.h" #include "getopt.h" extern const char * gdbm_version; extern const char *gdbm_strerror _ARGS((gdbm_error)); gdbm_file_info *gdbm_file; /* Debug procedure to print the contents of the current hash bucket. */ void print_bucket (bucket, mesg) hash_bucket *bucket; char *mesg; { int index; printf ("******* %s **********\n\nbits = %d\ncount= %d\nHash Table:\n", mesg, bucket->bucket_bits, bucket->count); printf (" # hash value key size data size data adr home\n"); for (index = 0; index < gdbm_file->header->bucket_elems; index++) printf (" %4d %12x %11d %11d %11d %5d\n", index, bucket->h_table[index].hash_value, bucket->h_table[index].key_size, bucket->h_table[index].data_size, bucket->h_table[index].data_pointer, bucket->h_table[index].hash_value % gdbm_file->header->bucket_elems); printf ("\nAvail count = %1d\n", bucket->av_count); printf ("Avail adr size\n"); for (index = 0; index < bucket->av_count; index++) printf ("%9d%9d\n", bucket->bucket_avail[index].av_adr, bucket->bucket_avail[index].av_size); } void _gdbm_print_avail_list (dbf) gdbm_file_info *dbf; { int temp; int size; avail_block *av_stk; /* Print the the header avail block. */ printf ("\nheader block\nsize = %d\ncount = %d\n", dbf->header->avail.size, dbf->header->avail.count); for (temp = 0; temp < dbf->header->avail.count; temp++) { printf (" %15d %10d \n", dbf->header->avail.av_table[temp].av_size, dbf->header->avail.av_table[temp].av_adr); } /* Initialize the variables for a pass throught the avail stack. */ temp = dbf->header->avail.next_block; size = ( ( (dbf->header->avail.size * sizeof (avail_elem)) >> 1) + sizeof (avail_block)); av_stk = (avail_block *) alloca (size); /* Print the stack. */ while (FALSE) { lseek (dbf->desc, temp, L_SET); read (dbf->desc, av_stk, size); /* Print the block! */ printf ("\nblock = %d\nsize = %d\ncount = %d\n", temp, av_stk->size, av_stk->count); for (temp = 0; temp < av_stk->count; temp++) { printf (" %15d %10d \n", av_stk->av_table[temp].av_size, av_stk->av_table[temp].av_adr); } temp = av_stk->next_block; } } void _gdbm_print_bucket_cache (dbf) gdbm_file_info *dbf; { register int index; char changed; if (dbf->bucket_cache != NULL) { printf( "Bucket Cache (size %d):\n Index: Address Changed Data_Hash \n", dbf->cache_size); for (index=0; index < dbf->cache_size; index++) { changed = dbf->bucket_cache[index].ca_changed; printf (" %5d: %7d %7s %x\n", index, dbf->bucket_cache[index].ca_adr, (changed ? "True" : "False"), dbf->bucket_cache[index].ca_data.hash_val); } } else printf("Bucket cache has not been initialized.\n"); } void usage (s) char *s; { printf( "Usage: %s [-r or -nf] [-b block-size] [-c cache-size] [-g gdbm-file]\n", s); exit (2); } /* The test program allows one to call all the routines plus the hash function. The commands are single letter commands. The user is prompted for all other information. See the help command (?) for a list of all commands. */ int main (argc, argv) int argc; char *argv[]; { char cmd_ch; datum key_data; datum data_data; datum return_data; char key_line[500]; char data_line[1000]; char done = FALSE; int opt; char reader = FALSE; char newdb = FALSE; int fast = 0; int cache_size = DEFAULT_CACHESIZE; int block_size = 0; char *file_name = NULL; /* Argument checking. */ opterr = 0; while ((opt = getopt (argc, argv, "frnc:b:g:")) != -1) switch (opt) { case 'f': fast = GDBM_FAST; if (reader) usage (argv[0]); break; case 'r': reader = TRUE; if (newdb) usage (argv[0]); break; case 'n': newdb = TRUE; if (reader) usage (argv[0]); break; case 'c': cache_size = atoi(optarg); break; case 'b': block_size = atoi(optarg); break; case 'g': file_name = optarg; break; default: usage(argv[0]); } if(file_name == NULL) file_name = "junk.gdbm"; /* Initialize variables. */ key_data.dptr = NULL; data_data.dptr = data_line; if (reader) { gdbm_file = gdbm_open (file_name, block_size, GDBM_READER, 00664, NULL); } else if (newdb) { gdbm_file = gdbm_open (file_name, block_size, GDBM_NEWDB | fast, 00664, NULL); } else { gdbm_file = gdbm_open (file_name, block_size, GDBM_WRCREAT | fast, 00664, NULL); } if (gdbm_file == NULL) { printf("gdbm_open failed, %s\n", gdbm_strerror(gdbm_errno)); exit (2); } if (gdbm_setopt(gdbm_file, GDBM_CACHESIZE, &cache_size, sizeof(int)) == -1) { printf("gdbm_setopt failed, %s\n", gdbm_strerror(gdbm_errno)); exit(2); } /* Welcome message. */ printf ("\nWelcome to the gdbm test program. Type ? for help.\n\n"); while (!done) { printf ("com -> "); cmd_ch = getchar (); if (cmd_ch != '\n') { char temp; do temp = getchar (); while (temp != '\n' && temp != EOF); } if (cmd_ch == EOF) cmd_ch = 'q'; switch (cmd_ch) { /* Standard cases found in all test{dbm,ndbm,gdbm} programs. */ case '\n': printf ("\n"); break; case 'c': { int temp; temp = 0; if (key_data.dptr != NULL) free (key_data.dptr); return_data = gdbm_firstkey (gdbm_file); while (return_data.dptr != NULL) { temp++; key_data = return_data; return_data = gdbm_nextkey (gdbm_file, key_data); free (key_data.dptr); } printf ("There are %d items in the database.\n\n", temp); key_data.dptr = NULL; } break; case 'd': if (key_data.dptr != NULL) free (key_data.dptr); printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; if (gdbm_delete (gdbm_file, key_data) != 0) printf ("Item not found or deleted\n"); printf ("\n"); key_data.dptr = NULL; break; case 'f': if (key_data.dptr != NULL) free (key_data.dptr); printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; return_data = gdbm_fetch (gdbm_file, key_data); if (return_data.dptr != NULL) { printf ("data is ->%s\n\n", return_data.dptr); free (return_data.dptr); } else printf ("No such item found.\n\n"); key_data.dptr = NULL; break; case 'n': if (key_data.dptr != NULL) free (key_data.dptr); printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; return_data = gdbm_nextkey (gdbm_file, key_data); if (return_data.dptr != NULL) { key_data = return_data; printf ("key is ->%s\n", key_data.dptr); return_data = gdbm_fetch (gdbm_file, key_data); printf ("data is ->%s\n\n", return_data.dptr); free (return_data.dptr); } else { printf ("No such item found.\n\n"); key_data.dptr = NULL; } break; case 'q': done = TRUE; break; case 's': if (key_data.dptr != NULL) free (key_data.dptr); printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; printf ("data -> "); gets (data_line); data_data.dsize = strlen (data_line)+1; if (gdbm_store (gdbm_file, key_data, data_data, GDBM_REPLACE) != 0) printf ("Item not inserted. \n"); printf ("\n"); key_data.dptr = NULL; break; case '1': if (key_data.dptr != NULL) free (key_data.dptr); key_data = gdbm_firstkey (gdbm_file); if (key_data.dptr != NULL) { printf ("key is ->%s\n", key_data.dptr); return_data = gdbm_fetch (gdbm_file, key_data); printf ("data is ->%s\n\n", return_data.dptr); free (return_data.dptr); } else printf ("No such item found.\n\n"); break; case '2': return_data = gdbm_nextkey (gdbm_file, key_data); if (return_data.dptr != NULL) { free (key_data.dptr); key_data = return_data; printf ("key is ->%s\n", key_data.dptr); return_data = gdbm_fetch (gdbm_file, key_data); printf ("data is ->%s\n\n", return_data.dptr); free (return_data.dptr); } else printf ("No such item found.\n\n"); break; /* Special cases for the testgdbm program. */ case 'r': { if (gdbm_reorganize (gdbm_file)) printf ("Reorganization failed. \n\n"); else printf ("Reorganization succeeded. \n\n"); } break; case 'A': _gdbm_print_avail_list (gdbm_file); printf ("\n"); break; case 'B': { int temp; char number[80]; printf ("bucket? "); gets (number); sscanf (number,"%d",&temp); if (temp >= gdbm_file->header->dir_size /4) { printf ("Not a bucket. \n\n"); break; } _gdbm_get_bucket (gdbm_file, temp); } printf ("Your bucket is now "); case 'C': print_bucket (gdbm_file->bucket, "Current bucket"); printf ("\n current directory entry = %d.\n", gdbm_file->bucket_dir); printf (" current bucket address = %d.\n\n", gdbm_file->cache_entry->ca_adr); break; case 'D': printf ("Hash table directory.\n"); printf (" Size = %d. Bits = %d. \n\n",gdbm_file->header->dir_size, gdbm_file->header->dir_bits); { int temp; for (temp = 0; temp < gdbm_file->header->dir_size / 4; temp++) { printf (" %10d: %12d\n", temp, gdbm_file->dir[temp]); if ( (temp+1) % 20 == 0 && isatty (0)) { printf ("*** CR to continue: "); while (getchar () != '\n') /* Do nothing. */; } } } printf ("\n"); break; case 'F': { printf ("\nFile Header: \n\n"); printf (" table = %d\n", gdbm_file->header->dir); printf (" table size = %d\n", gdbm_file->header->dir_size); printf (" table bits = %d\n", gdbm_file->header->dir_bits); printf (" block size = %d\n", gdbm_file->header->block_size); printf (" bucket elems = %d\n", gdbm_file->header->bucket_elems); printf (" bucket size = %d\n", gdbm_file->header->bucket_size); printf (" header magic = %x\n", gdbm_file->header->header_magic); printf (" next block = %d\n", gdbm_file->header->next_block); printf (" avail size = %d\n", gdbm_file->header->avail.size); printf (" avail count = %d\n", gdbm_file->header->avail.count); printf (" avail nx blk = %d\n", gdbm_file->header->avail.next_block); printf ("\n"); } break; case 'H': if (key_data.dptr != NULL) free (key_data.dptr); printf ("key -> "); gets (key_line); key_data.dptr = key_line; key_data.dsize = strlen (key_line)+1; printf ("hash value = %x. \n\n", _gdbm_hash (key_data)); key_data.dptr = NULL; break; case 'K': _gdbm_print_bucket_cache (gdbm_file); break; case 'V': printf ("%s\n\n", gdbm_version); break; case '?': printf ("c - count (number of entries)\n"); printf ("d - delete\n"); printf ("f - fetch\n"); printf ("n - nextkey\n"); printf ("q - quit\n"); printf ("s - store\n"); printf ("1 - firstkey\n"); printf ("2 - nextkey on last key (from n, 1 or 2)\n\n"); printf ("r - reorganize\n"); printf ("A - print avail list\n"); printf ("B - get and print current bucket n\n"); printf ("C - print current bucket\n"); printf ("D - print hash directory\n"); printf ("F - print file header\n"); printf ("H - hash value of key\n"); printf ("K - print the bucket cache\n"); printf ("V - print version of gdbm\n"); break; default: printf ("What? \n\n"); break; } } /* Quit normally. */ exit (0); } gdbm-1.7.2/gdbmdefs.h100600 24413 24 16422 5541053222 13130 0ustar downsjuser/* gdbmdefs.h - The include file for dbm. Defines structure and constants. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ #include "systems.h" #include "gdbmconst.h" /* The type definitions are next. */ /* The data and key structure. This structure is defined for compatibility. */ typedef struct { char *dptr; int dsize; } datum; /* The available file space is stored in an "avail" table. The one with most activity is contained in the file header. (See below.) When that one filles up, it is split in half and half is pushed on an "avail stack." When the active avail table is empty and the "avail stack" is not empty, the top of the stack is popped into the active avail table. */ /* The following structure is the element of the avaliable table. */ typedef struct { int av_size; /* The size of the available block. */ off_t av_adr; /* The file address of the available block. */ } avail_elem; /* This is the actual table. The in-memory images of the avail blocks are allocated by malloc using a calculated size. */ typedef struct { int size; /* The number of avail elements in the table.*/ int count; /* The number of entries in the table. */ off_t next_block; /* The file address of the next avail block. */ avail_elem av_table[1]; /* The table. Make it look like an array. */ } avail_block; /* The dbm file header keeps track of the current location of the hash directory and the free space in the file. */ typedef struct { word_t header_magic; /* 0x13579ace to make sure the header is good. */ int block_size; /* The optimal i/o blocksize from stat. */ off_t dir; /* File address of hash directory table. */ int dir_size; /* Size in bytes of the table. */ int dir_bits; /* The number of address bits used in the table.*/ int bucket_size; /* Size in bytes of a hash bucket struct. */ int bucket_elems; /* Number of elements in a hash bucket. */ off_t next_block; /* The next unallocated block address. */ avail_block avail; /* This must be last because of the psuedo array in avail. This avail grows to fill the entire block. */ } gdbm_file_header; /* The dbm hash bucket element contains the full 31 bit hash value, the "pointer" to the key and data (stored together) with their sizes. It also has a small part of the actual key value. It is used to verify the first part of the key has the correct value without having to read the actual key. */ typedef struct { word_t hash_value; /* The complete 31 bit value. */ char key_start[SMALL]; /* Up to the first SMALL bytes of the key. */ off_t data_pointer; /* The file address of the key record. The data record directly follows the key. */ int key_size; /* Size of key data in the file. */ int data_size; /* Size of associated data in the file. */ } bucket_element; /* A bucket is a small hash table. This one consists of a number of bucket elements plus some bookkeeping fields. The number of elements depends on the optimum blocksize for the storage device and on a parameter given at file creation time. This bucket takes one block. When one of these tables gets full, it is split into two hash buckets. The contents are split between them by the use of the first few bits of the 31 bit hash function. The location in a bucket is the hash value modulo the size of the bucket. The in-memory images of the buckets are allocated by malloc using a calculated size depending of the file system buffer size. To speed up write, each bucket will have BUCKET_AVAIL avail elements with the bucket. */ typedef struct { int av_count; /* The number of bucket_avail entries. */ avail_elem bucket_avail[BUCKET_AVAIL]; /* Distributed avail. */ int bucket_bits; /* The number of bits used to get here. */ int count; /* The number of element buckets full. */ bucket_element h_table[1]; /* The table. Make it look like an array.*/ } hash_bucket; /* We want to keep from reading buckets as much as possible. The following is to implement a bucket cache. When full, buckets will be dropped in a least recently read from disk order. */ /* To speed up fetching and "sequential" access, we need to implement a data cache for key/data pairs read from the file. To find a key, we must exactly match the key from the file. To reduce overhead, the data will be read at the same time. Both key and data will be stored in a data cache. Each bucket cached will have a one element data cache. */ typedef struct { word_t hash_val; int data_size; int key_size; char *dptr; int elem_loc; } data_cache_elem; typedef struct { hash_bucket * ca_bucket; off_t ca_adr; char ca_changed; /* Data in the bucket changed. */ data_cache_elem ca_data; } cache_elem; /* This final structure contains all main memory based information for a gdbm file. This allows multiple gdbm files to be opened at the same time by one program. */ typedef struct { /* Global variables and pointers to dynamic variables used by gdbm. */ /* The file name. */ char *name; /* The reader/writer status. */ int read_write; /* Fast_write is set to 1 if no fsyncs are to be done. */ int fast_write; /* The fatal error handling routine. */ void (*fatal_err) (); /* The gdbm file descriptor which is set in gdbm_open. */ int desc; /* The file header holds information about the database. */ gdbm_file_header *header; /* The hash table directory from extendible hashing. See Fagin et al, ACM Trans on Database Systems, Vol 4, No 3. Sept 1979, 315-344 */ off_t *dir; /* The bucket cache. */ cache_elem *bucket_cache; int cache_size; int last_read; /* Points to the current hash bucket in the cache. */ hash_bucket *bucket; /* The directory entry used to get the current hash bucket. */ word_t bucket_dir; /* Pointer to the current bucket's cache entry. */ cache_elem *cache_entry; /* Bookkeeping of things that need to be written back at the end of an update. */ char header_changed; char directory_changed; char bucket_changed; char second_changed; } gdbm_file_info; /* Now define all the routines in use. */ #include "proto.h" gdbm-1.7.2/extern.h100600 24413 24 2616 5544000070 12636 0ustar downsjuser/* extern.h - The collection of external definitions needed. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* The global variables used for the "original" interface. */ extern gdbm_file_info *_gdbm_file; /* Memory for return data for the "original" interface. */ extern datum _gdbm_memory; extern char *_gdbm_fetch_val; gdbm-1.7.2/gdbmerrno.h100600 24413 24 3472 5464442047 13330 0ustar downsjuser/* gdbmerrno.h - The enumeration type describing all the dbm errors. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* gdbm sends back the following error codes in the variable gdbm_errno. */ typedef enum { GDBM_NO_ERROR, GDBM_MALLOC_ERROR, GDBM_BLOCK_SIZE_ERROR, GDBM_FILE_OPEN_ERROR, GDBM_FILE_WRITE_ERROR, GDBM_FILE_SEEK_ERROR, GDBM_FILE_READ_ERROR, GDBM_BAD_MAGIC_NUMBER, GDBM_EMPTY_DATABASE, GDBM_CANT_BE_READER, GDBM_CANT_BE_WRITER, GDBM_READER_CANT_DELETE, GDBM_READER_CANT_STORE, GDBM_READER_CANT_REORGANIZE, GDBM_UNKNOWN_UPDATE, GDBM_ITEM_NOT_FOUND, GDBM_REORGANIZE_FAILED, GDBM_CANNOT_REPLACE, GDBM_ILLEGAL_DATA, GDBM_OPT_ALREADY_SET, GDBM_OPT_ILLEGAL} gdbm_error; extern gdbm_error gdbm_errno; gdbm-1.7.2/systems.h100600 24413 24 7332 5507267310 13053 0ustar downsjuser/* systems.h - Most of the system dependant code and defines are here. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ #ifdef __GNUC__ #define alloca __builtin_alloca #else /* not __GNUC__ */ #ifdef HAVE_ALLOCA_H #include #endif /* not HAVE_ALLOCA_H */ #endif /* not __GNUC__ */ /* Include all system headers first. */ #if HAVE_SYS_TYPES_H #include #endif #include #if HAVE_SYS_FILE_H #include #endif #include #if HAVE_STDLIB_H #include #endif #if HAVE_STRING_H #include #else #include #endif #if HAVE_UNISTD_H #include #endif #if HAVE_FCNTL_H #include #endif #ifndef SEEK_SET #define SEEK_SET 0 #endif #ifndef L_SET #define L_SET SEEK_SET #endif /* Do we have flock? (BSD...) */ #if HAVE_FLOCK #ifndef LOCK_SH #define LOCK_SH 1 #endif #ifndef LOCK_EX #define LOCK_EX 2 #endif #ifndef LOCK_NB #define LOCK_NB 4 #endif #ifndef LOCK_UN #define LOCK_UN 8 #endif #define UNLOCK_FILE(dbf) flock (dbf->desc, LOCK_UN) #define READLOCK_FILE(dbf) lock_val = flock (dbf->desc, LOCK_SH + LOCK_NB) #define WRITELOCK_FILE(dbf) lock_val = flock (dbf->desc, LOCK_EX + LOCK_NB) #else /* Assume it is done like System V. */ #define UNLOCK_FILE(dbf) \ { \ struct flock flock; \ flock.l_type = F_UNLCK; \ flock.l_whence = SEEK_SET; \ flock.l_start = flock.l_len = 0L; \ fcntl (dbf->desc, F_SETLK, &flock); \ } #define READLOCK_FILE(dbf) \ { \ struct flock flock; \ flock.l_type = F_RDLCK; \ flock.l_whence = SEEK_SET; \ flock.l_start = flock.l_len = 0L; \ lock_val = fcntl (dbf->desc, F_SETLK, &flock); \ } #define WRITELOCK_FILE(dbf) \ { \ struct flock flock; \ flock.l_type = F_WRLCK; \ flock.l_whence = SEEK_SET; \ flock.l_start = flock.l_len = 0L; \ lock_val = fcntl (dbf->desc, F_SETLK, &flock); \ } #endif /* Do we have bcopy? */ #if !HAVE_BCOPY #if HAVE_MEMORY_H #include #endif #define bcmp(d1, d2, n) memcmp(d1, d2, n) #define bcopy(d1, d2, n) memcpy(d2, d1, n) #endif /* Do we have fsync? */ #if !HAVE_FSYNC #define fsync(f) {sync(); sync();} #endif /* Default block size. Some systems do not have blocksize in their stat record. This code uses the BSD blocksize from stat. */ #if HAVE_ST_BLKSIZE #define STATBLKSIZE file_stat.st_blksize #else #define STATBLKSIZE 1024 #endif /* Do we have ftruncate? */ #if HAVE_FTRUNCATE #define TRUNCATE(dbf) ftruncate (dbf->desc, 0) #else #define TRUNCATE(dbf) close( open (dbf->name, O_RDWR|O_TRUNC, mode)); #endif /* Do we have 32bit or 64bit longs? */ #if LONG_64_BITS || !INT_16_BITS typedef int word_t; #else typedef long word_t; #endif gdbm-1.7.2/dbm.h100600 24413 24 3033 5464415771 12110 0ustar downsjuser/* dbm.h - The include file for dbm users. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* The data and key structure. This structure is defined for compatibility. */ typedef struct { char *dptr; int dsize; } datum; /* These are the routines in dbm. */ extern int dbminit (); extern datum fetch (); extern int store (); extern int delete (); extern int delete (); extern datum firstkey (); extern datum nextkey (); extern int dbmclose (); gdbm-1.7.2/ndbm.h100600 24413 24 3723 5464416416 12271 0ustar downsjuser/* ndbm.h - The include file for ndbm users. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* Parameters to dbm_store for simple insertion or replacement. */ #define DBM_INSERT 0 #define DBM_REPLACE 1 /* The data and key structure. This structure is defined for compatibility. */ typedef struct { char *dptr; int dsize; } datum; /* The file information header. This is good enough for most applications. */ typedef struct {int dummy[10];} DBM; /* These are the routines (with some macros defining them!) */ extern DBM *dbm_open (); extern void dbm_close (); extern datum dbm_fetch (); extern int dbm_store (); extern int dbm_delete (); extern int dbm_delete (); extern datum dbm_firstkey (); extern datum dbm_nextkey (); #define dbm_error(dbf) (0) #define dbm_clearerr(dbf) extern int dbm_dirfno (); extern int dbm_pagfno (); extern int dbm_rdonly (); gdbm-1.7.2/gdbmconst.h100600 24413 24 5110 5541047316 13314 0ustar downsjuser/* gdbmconst.h - The constants defined for use in gdbm. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* Start with the constant definitions. */ #define TRUE 1 #define FALSE 0 /* Parameters to gdbm_open. */ #define GDBM_READER 0 /* READERS only. */ #define GDBM_WRITER 1 /* READERS and WRITERS. Can not create. */ #define GDBM_WRCREAT 2 /* If not found, create the db. */ #define GDBM_NEWDB 3 /* ALWAYS create a new db. (WRITER) */ #define GDBM_FAST 16 /* Write fast! => No fsyncs. */ /* Parameters to gdbm_store for simple insertion or replacement in the case a key to store is already in the database. */ #define GDBM_INSERT 0 /* Do not overwrite data in the database. */ #define GDBM_REPLACE 1 /* Replace the old value with the new value. */ /* Parameters to gdbm_setopt, specifing the type of operation to perform. */ #define GDBM_CACHESIZE 1 /* Set the cache size. */ #define GDBM_FASTMODE 2 /* Turn on or off fast mode. */ /* In freeing blocks, we will ignore any blocks smaller (and equal) to IGNORE_SIZE number of bytes. */ #define IGNORE_SIZE 4 /* The number of key bytes kept in a hash bucket. */ #define SMALL 4 /* The number of bucket_avail entries in a hash bucket. */ #define BUCKET_AVAIL 6 /* The size of the bucket cache. */ #define DEFAULT_CACHESIZE 100 /* Header magic numbers */ #define MAGIC_OLD 0x13579ACE /* old file magic number */ #define MAGIC_PURE 0x24780BDF /* new file magic number */ #define MAGIC_REVERSED 0xDF0B7824 /* reversed byte order new file */ gdbm-1.7.2/proto.h100600 24413 24 6301 5464672732 12514 0ustar downsjuser/* proto.h - The prototypes for the dbm routines. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* Define our _PROTOTYPE macro. */ #ifdef _ARGS #undef _ARGS #endif #ifdef __STDC__ #define _ARGS(args) args #else #define _ARGS(args) () #endif /* From bucket.c */ void _gdbm_new_bucket _ARGS((gdbm_file_info *dbf, hash_bucket *bucket, int bits )); void _gdbm_get_bucket _ARGS((gdbm_file_info *dbf, word_t dir_index )); void _gdbm_split_bucket _ARGS((gdbm_file_info *dbf, word_t next_insert )); void _gdbm_write_bucket _ARGS((gdbm_file_info *dbf, cache_elem *ca_entry )); /* From falloc.c */ off_t _gdbm_alloc _ARGS((gdbm_file_info *dbf, int num_bytes )); void _gdbm_free _ARGS((gdbm_file_info *dbf, off_t file_adr, int num_bytes )); int _gdbm_put_av_elem _ARGS((avail_elem new_el, avail_elem av_table [], int *av_count )); /* From findkey.c */ char *_gdbm_read_entry _ARGS((gdbm_file_info *dbf, int elem_loc)); int _gdbm_findkey _ARGS((gdbm_file_info *dbf, datum key, char **dptr, word_t *new_hash_val)); /* From hash.c */ word_t _gdbm_hash _ARGS((datum key )); /* From update.c */ void _gdbm_end_update _ARGS((gdbm_file_info *dbf )); int _gdbm_fatal _ARGS((gdbm_file_info *dbf, char *val )); /* From gdbmopen.c */ int _gdbm_init_cache _ARGS((gdbm_file_info *dbf, int size)); /* The user callable routines.... */ void gdbm_close _ARGS((gdbm_file_info *dbf )); int gdbm_delete _ARGS((gdbm_file_info *dbf, datum key )); datum gdbm_fetch _ARGS((gdbm_file_info *dbf, datum key )); gdbm_file_info *gdbm_open _ARGS((char *file, int block_size, int flags, int mode, void (*fatal_func) (void))); int gdbm_reorganize _ARGS((gdbm_file_info *dbf )); datum gdbm_firstkey _ARGS((gdbm_file_info *dbf )); datum gdbm_nextkey _ARGS((gdbm_file_info *dbf, datum key )); int gdbm_store _ARGS((gdbm_file_info *dbf, datum key, datum content, int flags )); int gdbm_exists _ARGS((gdbm_file_info *dbf, datum key)); void gdbm_sync _ARGS((gdbm_file_info *dbf)); int gdbm_setopt _ARGS((gdbm_file_info *dbf, int optflag, int *optval, int optlen)); gdbm-1.7.2/COPYING100600 24413 24 43100 5422575344 12244 0ustar downsjuser GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. gdbm-1.7.2/ChangeLog100600 24413 24 30442 5565367007 12773 0ustar downsjuserSun May 15 02:39:48 1994 jason downs (downsj@csos.orst.edu) * gdbm.3, gdbm.texinfo: updates for 1.7.2 * README, NEWS, version.c: update for 1.7.2 * Makefile.in: removed files, changed (drastically) how the package compiles and installs. * bytewise.c, bytewise.h: removed from this branch. Wed Mar 23 00:44:43 1994 jason downs (downsj@csos.orst.edu) * extern.h: removed bogus (old) function declarations. Mon Mar 14 01:37:09 1994 jason downs (downsj@csos.orst.edu) * Makefile.in: added new files. * bytewise.c, bytewise.h: new portable byte order conversion package; supports 64bit longs/16bit ints. Sun Mar 13 22:56:10 1994 jason downs (downsj@csos.orst.edu) * gdbmsetopt.c, gdbmconst.h: added GDBM_FASTMODE option. * falloc.c: taught _gdbm_alloc() about the header avail table. hopefully, this will fix the bloating problem. i dunno, though, as i've never had that problem, myself. Sun Dec 26 05:17:04 1993 jason downs (downsj@csos.orst.edu) * version.c: made gdbm_version const. * gdbmerrno.c: made gdbm_strerror() and it's array const. * various files: general clean up, reformating of code. * systems.h: put inside of a conditional. * configure.in, autoconf.h.in: added check for . * systems.h: added a default define of SEEK_SET. * bucket.c, gdbmopen.c, gdbmseq.c, gdbmdelete.c, gdbmdefs.h: cleaned up some uses of word_t. Tue Nov 16 03:11:56 1993 jason downs (downsj@csos.orst.edu) * gdbm.3, gdbm.texinfo: updated versions to 1.3 for release * version.c, README, NEWS: updated versions to 1.7.1 for release Sun Nov 14 17:21:03 1993 jason downs (downsj@csos.orst.edu) * Makefile.in: added $(srcdir) to a few file references. Sat Nov 13 13:56:37 1993 jason downs (downsj@csos.orst.edu) * gdbm.3, gdbm.texinfo: added new gdbm_firstkey()/gdbm_nextkey() documentation. * gdbmopen.c: added SGI alloca patch. * Makefile.in: changed installation prefix semantics. Sat Nov 13 01:52:31 1993 jason downs (downsj@csos.orst.edu) * various source: redid the AIX alloca declaration. any new files that call alloca will have to start with the same header. * all source, configure.in, Makefile.in: switched over to using autoconf.h, rather than packing all of the autoconf defs into the DEFS line. * autoconf.h.in: new file. * Makefile.in: changed rule for tndbm.o, hopefully making it more portable. * alloca.c: added inclusion of stdlib.h Fri Nov 12 13:11:03 1993 jason downs (downsj@csos.orst.edu) * Makefile.in, configure.in: fixed getop related bugs. * systems.h: moved sys/types.h include to top. Wed Nov 3 17:18:59 1993 jason downs (downsj@csos.orst.edu) * version.c: changed version to 1.7, for release. * gdbmdefs.h: Moved all system includes to systems.h. Sun Oct 31 02:50:12 1993 jason downs (downsj@csos.orst.edu) * version.c: changed version number to 1.7alpha. * gdbm.texinfo: updated to reflect new routines and changes. * getopt.c, getopt.h: Added the GNU getopt.c to the dist, for compilation of testgdbm and conv2gdbm on machines without getopt(). * various source files: changed all appropiate occurances of 'long' to type 'off_t'. Added off_t check to configure.in. * gdbm.3: updated to reflect new routines and changes. Sat Oct 30 05:20:45 1993 jason downs (downsj@csos.orst.edu) * testgdbm.c: Added support for bucket cache and block sizes, adding -c, -b and -g flags. Must use -g to specify the file name, now. * bucket.c, gdbmopen.c, gdbmclose.c, gdbmreorg.c, update.c, gdbmconst.h, gdbmdefs.h: Implemented dynamic, delayed initialization, bucket cache. New routine: _gdbm_init_cache(). * proto.h, gdbmerrno.c, gdbmerrno.h: Added gdbm_setopt() errors and prototypes. * gdbmsetopt.c: New file, implements the gdbm_setopt() routine. * testgdbm.c, testndbm.c, testdbm.c, conv2gdbm.c: cleaned up compiler warnings. * update.c: repaired declarations and added prototypes for static routines, repaired declaration of _gdbm_fatal(). * falloc.c: repaired declarations and added prototypes for static routines. * gdbmstore.c: commented out unsed variables in gdbm_store(). * proto.h: added prototypes for _gdbm_read_entry(), _gdbm_find_key(), and gdbm_sync(). * bucket.c, proto.h: changed _gdbm_get_bucket() and _gdbm_write_bucket() over to type void. Sat Oct 30 00:56:24 1993 jason downs (downsj@csos.orst.edu) * gdbmerrno.c, gdbmexists.c, close.c, dbmrdonly.c: New files, adding the routines gdbm_strerror(), gdbm_exists(), and for better compatibility with the old dbm/ndbm libraries, the dbmclose() and dbm_rdonly() routines. * various headers: Added prototypes for the new routines, and rearranged how gdbm.h is generated. Fri Oct 29 07:02:41 1993 jason downs (downsj@csos.orst.edu) * README: split into README, INSTALL, and NEWS. INSTALL includes more tips on compiling. NEWS contains the 'short form' ChangeLog. * Makefile.in, configure.in: Redid parts of the autoconf stuff, and repaired many bugs. * systems.h: Repaired the alloca declarations, among other things. * various source files: changed all relevant usage of type 'long' to type 'word_t', which will always be 32bits wide. 'word_t' is defined in systems.h. Fri Jul 30 13:27:24 1993 Phil Nelson (phil@cs.wwu.edu) * findkey.c: Added a check of elem_loc == -1 in determining if the data cache held the item being looked for. Tue Jul 20 13:08:47 1993 Phil Nelson (phil at cs.wwu.edu) * gdbm.texinfo: Fixed some errors. * Makefile.in: Fixed some errors. * version.c: Set version to 1.6 for release. Mon Jul 19 15:02:40 1993 Phil Nelson (phil at cs.wwu.edu) * COPYING: Replaced Version 1 with Version 2. Also updated all file notices to refer to version 2. * gdbm.texinfo: Updated the documentation. * README: Updated to current version. * Makefile: updated clean and install. Wed Jul 14 13:37:44 1993 Phil Nelson (phil at cs.wwu.edu) * Makfile.in: Added samp1.cc to the list of distributed files. Sat Jun 5 21:35:59 1993 Phil Nelson (phil at cs.wwu.edu) * gdbm.proto, Makefile.in: Added #ifndef _GDBM_H_ protection for the final gdbm.h file. Also added prototypes and C++ support. * gdbmseq.c: Added gdbm_errno initialization to gdbm_nextkey. * gdbmerrno.h and others: Moved the extern definition of gdbm_erron to gdbmerrno.h from the other files. Mon May 17 12:32:02 1993 Phil Nelson (phil at cs.wwu.edu) * gdbm.proto: Added GDBM_FAST to the read_write flags. Sun May 16 12:50:01 1993 Phil Nelson (phil at cs.wwu.edu) * configure.in, Makefile.in: Added autoconf configuration to gdbm. Tue Mar 30 00:08:48 1993 Phil Nelson (phil at cs.wwu.edu) * global.c: Set gdbm_errno to GDBM_NO_ERROR to force it into the data segment. Sun Mar 28 22:51:40 1993 Phil Nelson (phil at cs.wwu.edu) * gdbmfetch.c: Set return_val.dsize to 0 as a default return value. (I was told that was more compatible with dbm/ndbm.) * gdbmopen.c: Changed a "sizeof(int)" to "sizeof(long)". * testgdbm.c: Changed "char opt" to "int opt" to make sure opt can be -1. * hash.c: Added "unsigned" to declaration of value for better overflow operation. * gdbmreorg.c: Added a free for data.dptr in the main loop. Also changed the malloc for new_name to an alloca. Removed all frees on new_name. Sat Mar 27 23:25:14 1993 Phil Nelson (phil at cs.wwu.edu) * gdbmconst.h, gdbmdefs.h, gdbmopen.c, gdbmreorg.c, testgdbm.c, update.c, gdbm.h: Added code to allow for a GDBM_FAST mode in which fsync is not called during database update mode. Added a new flag "-f" to testgdbm to make use of the new fast mode. * gdbmsync.c: Added this function to allow a programmer to use the GDBM_FAST mode but still be able to sync a database. * gdbmopen.c, gdbmdelete.c, gdbmfetch.c, gdbmseq.c, gdbmstore.c, gdbmreorg.c: Added initialization of gdbm_errno to GDBM_NO_ERROR. Mon Mar 22 23:03:36 1993 Phil Nelson (phil at cs.wwu.edu) * gdbmclose.c: (gdbmclose) Added a fsync before close to make sure the file is written to disk before continuing. Sun Mar 21 21:33:31 1993 Phil Nelson (phil at cs.wwu.edu) * proto.h: Added this as a new file. It adds ANSI prototypes for ANSI compilers. * gdbmdefs.h: Added an include of proto.h. * Makefile: Added proper references to proto.h * gdbmopen.c: Changed (int *) casts to (long *) and added an initialization to dbf->header. * gdbmreorg.c: Added an "end update" on the new database and correctly set up the bucket cache. * update.c: (_gdbm_end_update) Added type void to header. Wed Mar 17 19:14:27 1993 Phil Nelson (phil at cs.wwu.edu) * Changed copyright on all files to include 1993. Also deleted all references to my phone number. Thu Feb 28 17:05:09 1991 Phil Nelson (phil at strawberry.cs.wwu.edu) * Added 1991 to copyright lines on all files. * gdbmfetch.c: Fixed a bug introduced by previous changes. * version.c: Updated version to 1.5. Fri Feb 8 12:27:13 1991 Phil Nelson (phil at strawberry.cs.wwu.edu) * Change author's e-mail address in all comments. * gdbmopen.c, systems.h: Changed opening sequence so that a database will not be truncated in NEWDB mode until the write has locked the file. * testgdbm.c: Fixed a bug that caused a segmentation fault on one computer. Also added the flags "-r" for opening the database as a READER and "-n" for opening the database as a NEWDB writer. The default mode remains the WRCREAT mode. * Various source files, changed the data types of various variables from int to long. This should not make any difference to systems where sizeof(int) = sizeof(long). It should make it easier to move to other systems. * gdbmstore.c: Added a check for NULL key or content dptr. Due to NULLs being used as error indications, data cannot be NULL also. * gdbmfetch.c, gdbmseq.c, fetch.c: Added checks for zero sized key and content so malloc will not try to allocate zero bytes. * gdbmconst.h: Added this file so that all constants are in one central place. A few constants can be changed without changing the header sizes. Tue Aug 14 13:08:43 1990 Phil Nelson (phil at unicorn.wwu.edu) * Version 1.4 released. (version.c: Updated to correct version.) * Makefile: Added $(LIBS) to link for conv2gdbm. * README: Updated to version 1.4 and added a 1.0-1.4 change statement. Wed Aug 8 16:57:29 1990 Phil Nelson (phil at unicorn.wwu.edu) * gdbmopen.c: Restructured some code to initialize dbf more completely. * dbm.h: Added a null define to satisfy some versions that require a dbmclose() call. * findkey.c: (_gdbm_findkey) Added a check for the NULL pointer in ...ca_data.dptr. * gdbmdelete.c: Added code to more completely remove the cache entry for a deleted item. * gdbmreorg.c: Added code to finish the transfer of information from the new_dbf to the orginal dbf. Fri May 30 08:29:16 1990 Phil Nelson (phil at unicorn.wwu.edu) * gdbmstore.c: Changed a strncpy to bcopy. Tue May 15 09:55:21 1990 Phil Nelson (phil at unicorn.wwu.edu) * Version 1.3 released. * systems.h: Changed the defines for alloca to use the name builtin_alloca to depend on BUILTIN_ALLOCA instead of __GNUC__. Added a definition of BUILTIN_ALLOCA for GNUC and for sun sparc. Fri May 11 12:15:56 1990 Phil Nelson (phil at unicorn.wwu.edu) * systems.h: Removed the include for and now systems.h requires included before it. * Makefile: Corrected the makefile to include a file that was missing before. Also, switched order of conv2gdbm and alldbm in the all option. * findkey.c (_gdbm_read_entry): Reordered some statements to make the code more readable. * update.c (_gdbm_fatal): Changed fatal message from "dbm fatal:" to "gdbm fatal:". Mon Apr 30 10:18:24 1990 Phil Nelson (phil at unicorn.wwu.edu) * Version 1.2 released. Fri Apr 27 09:49:59 1990 Phil Nelson (phil at unicorn.wwu.edu) * Makefile: Added the dist option. Similar to the addition from hack@ai.mit.edu, but correct. * falloc.c (push_avail_block): Change the avail count to reflect the correct number of entries. * dbminit.c (dbminit): Changed the stat call to stat the ".dir" file as is done in dbmopen.c (dbm_open). Tue Apr 10 12:18:40 1990 Phil Nelson (phil at unicorn.wwu.edu) * Version 1.1. released. * gdbmopen.c (gdbm_open): Clear out bucket cache. gdbm-1.7.2/Makefile.in100600 24413 24 13627 5565365521 13273 0ustar downsjuser#### Start of system configuration section. #### srcdir = @srcdir@ VPATH = @srcdir@ CC = @CC@ INSTALL = @INSTALL@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_DATA = @INSTALL_DATA@ MAKEINFO = makeinfo TEXI2DVI = texi2dvi RANLIB = @RANLIB@ DEFS = # Where the system [n]dbm routines are... LIBS = @LIBS@ -lc # SunOS users might wish to add '-fpcc-struct-return' to CFLAGS. see INSTALL. CFLAGS = -O LDFLAGS = # Common prefix for installation directories prefix = /usr/local exec_prefix = $(prefix) binprefix = $(exec_prefix) manprefix = $(prefix) # Directory in which to put libgdbm.a. libdir = $(exec_prefix)/lib # The include directory for gdbm.h and dbm.h. includedir = $(prefix)/include # Info and man directories. infodir = $(prefix)/info man3dir = $(prefix)/man/man3 manext = 3 #### End of system configuration section. #### .c.o: $(CC) -c $(CPPFLAGS) $(DEFS) -I. -I$(srcdir) $(CFLAGS) $< SHELL = /bin/sh PROGS = libgdbm.a testgdbm testdbm testndbm tndbm tdbm conv2gdbm DBM_CF = dbminit.c delete.c fetch.c store.c seq.c close.c NDBM_CF = dbmopen.c dbmdelete.c dbmfetch.c dbmstore.c dbmseq.c \ dbmclose.c dbmdirfno.c dbmpagfno.c dbmrdonly.c GDBM_CF = gdbmopen.c gdbmdelete.c gdbmfetch.c gdbmstore.c gdbmclose.c \ gdbmreorg.c gdbmseq.c gdbmsync.c gdbmerrno.c gdbmexists.c gdbmsetopt.c \ bucket.c falloc.c findkey.c global.c hash.c update.c \ version.c TEST_CF = testdbm.c testndbm.c testgdbm.c DBM_OF = dbminit.o delete.o fetch.o store.o seq.o close.o NDBM_OF = dbmopen.o dbmdelete.o dbmfetch.o dbmstore.o dbmseq.o \ dbmclose.o dbmdirfno.o dbmpagfno.o dbmrdonly.o GDBM_OF = gdbmopen.o gdbmdelete.o gdbmfetch.o gdbmstore.o gdbmclose.o \ gdbmreorg.o gdbmseq.o gdbmsync.o gdbmerrno.o gdbmexists.o gdbmsetopt.o \ bucket.o falloc.o findkey.o global.o hash.o update.o \ version.o TEX_F = gdbm.aux gdbm.cp gdbm.dvi gdbm.fn gdbm.ky gdbm.log gdbm.pg \ gdbm.toc gdbm.tp gdbm.vr TEXI_F = gdbm.info SRCS = $(DBM_CF) $(NDBM_CF) $(GDBM_CF) $(TEST_CF) OBJS = $(DBM_OF) $(NDBM_OF) $(GDBM_OF) @ALLOCA@ HDRS = gdbmdefs.h extern.h gdbmerrno.h systems.h dbm.h ndbm.h gdbmconst.h \ proto.h MSCFILES = COPYING ChangeLog Makefile.in README gdbm.3 gdbm.texinfo \ gdbm.info NEWS INSTALL gdbm.proto gdbm.proto2 conv2gdbm.c \ configure configure.in alloca.c getopt.c getopt.h samp1.cc \ autoconf.h.in DISTFILES = $(SRCS) $(HDRS) $(MSCFILES) all: libgdbm.a progs: $(PROGS) install: libgdbm.a gdbm.h gdbm.info $(INSTALL_DATA) libgdbm.a $(libdir)/libgdbm.a $(INSTALL_DATA) gdbm.h $(includedir)/gdbm.h $(INSTALL_DATA) $(srcdir)/gdbm.3 $(man3dir)/gdbm.3 $(INSTALL_DATA) $(srcdir)/gdbm.info $(infodir)/gdbm.info install-compat: $(INSTALL_DATA) $(srcdir)/dbm.h $(includedir)/dbm.h $(INSTALL_DATA) $(srcdir/ndbm.h $(includedir)/ndbm.h libgdbm.a: $(OBJS) gdbm.h rm -f libgdbm.a ar q libgdbm.a $(OBJS) $(RANLIB) libgdbm.a gdbm.h: gdbm.proto gdbmerrno.h gdbm.proto2 rm -f gdbm.h cp $(srcdir)/gdbm.proto gdbm.h chmod +w gdbm.h grep _ $(srcdir)/gdbmerrno.h >> gdbm.h cat $(srcdir)/gdbm.proto2 >> gdbm.h chmod -w gdbm.h testgdbm: testgdbm.o libgdbm.a @LIBOBJS@ $(CC) $(LDFLAGS) -o testgdbm testgdbm.o libgdbm.a @LIBOBJS@ testdbm: testdbm.o libgdbm.a $(CC) $(LDFLAGS) -o testdbm testdbm.o libgdbm.a tdbm: testdbm.o libgdbm.a $(CC) $(LDFLAGS) -o tdbm testdbm.o $(LIBS) testndbm.o: testndbm.c $(CC) -c -I. -I$(srcdir) $(CFLAGS) $(DEFS) -DGNU $(srcdir)/testndbm.c testndbm: testndbm.o libgdbm.a $(CC) $(LDFLAGS) -o testndbm testndbm.o libgdbm.a tndbm.o: testndbm.c cp $(srcdir)/testndbm.c ./tndbm.c $(CC) -c -I. -I$(srcdir) $(CFLAGS) $(DEFS) ./tndbm.c rm -f ./tndbm.c tndbm: tndbm.o libgdbm.a $(CC) $(LDFLAGS) -o tndbm tndbm.o $(LIBS) conv2gdbm: conv2gdbm.o libgdbm.a @LIBOBJS@ $(CC) $(LDFLAGS) -o conv2gdbm conv2gdbm.o $(LIBS) libgdbm.a @LIBOBJS@ lintgdbm: lint $(DEFS) $(LFLAGS) $(DBM_CF) $(NDBM_CF) $(GDBM_CF) testgdbm.c TAGS: $(SRCS) etags $(SRCS) info: gdbm.info gdbm.info: $(MAKEINFO) $(srcdir)/gdbm.texinfo dvi: gdbm.dvi gdbm.dvi: $(TEXI2DVI) $(srcdir)/gdbm.texinfo clean: rm -f $(PROGS) $(TEX_F) *.o core junk* mostlyclean: clean distclean: clean rm -f Makefile autoconf.h config.status gdbm.h $(TEXI_F) *~ realclean: distclean rm -f TAGS -rm -f \ `sed -n 's/.*\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*/gdbm-\1/p' \ version.c`.tar.gz dist: echo \ `sed -n 's/.*\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*/gdbm-\1/p' \ version.c` > .fname rm -rf `cat .fname` mkdir `cat .fname` ln $(DISTFILES) `cat .fname` tar chf `cat .fname`.tar `cat .fname` gzip `cat .fname`.tar rm -rf `cat .fname` .fname # dbm files dbminit.o: autoconf.h gdbmdefs.h proto.h extern.h gdbmerrno.h delete.o: autoconf.h gdbmdefs.h proto.h extern.h fetch.o: autoconf.h gdbmdefs.h proto.h extern.h store.o: autoconf.h gdbmdefs.h proto.h extern.h seq.o: autoconf.h gdbmdefs.h proto.h extern.h # ndbm files dbmopen.o: autoconf.h gdbmdefs.h extern.h gdbmerrno.h dbmdelete.o: autoconf.h gdbmdefs.h extern.h dbmfetch.o: autoconf.h gdbmdefs.h extern.h dbmstore.o: autoconf.h gdbmdefs.h extern.h dbmseq.o: autoconf.h gdbmdefs.h extern.h dbmclose.o: autoconf.h gdbmdefs.h systems.h dbmpagfno.o: autoconf.h gdbmdefs.h extern.h dbmdirfno.o: autoconf.h gdbmdefs.h extern.h # gdbm files gdbmclose.o: autoconf.h gdbmdefs.h gdbmdelete.o: autoconf.h gdbmdefs.h gdbmerrno.h gdbmfetch.o: autoconf.h gdbmdefs.h gdbmerrno.h gdbmopen.o: autoconf.h gdbmdefs.h gdbmerrno.h gdbmreorg.o: autoconf.h gdbmdefs.h gdbmerrno.h extern.h gdbmseq.o: autoconf.h gdbmdefs.h gdbmstore.o: autoconf.h gdbmdefs.h gdbmerrno.h # gdbm support files bucket.o: autoconf.h gdbmdefs.h falloc.o: autoconf.h gdbmdefs.h findkey.o: autoconf.h gdbmdefs.h global.o: autoconf.h gdbmdefs.h gdbmerrno.h hash.o: autoconf.h gdbmdefs.h update.o: autoconf.h gdbmdefs.h version.o: extern.h: gdbmdefs.h: gdbmconst.h systems.h touch gdbmdefs.h # other programs testgdbm.o: autoconf.h gdbmdefs.h extern.h gdbmerrno.h systems.h testdbm.o: autoconf.h testndbm.o: autoconf.h ndbm.h tdbm.o: autoconf.h conv2gdbm.o: autoconf.h gdbm.h gdbm-1.7.2/README100600 24413 24 4154 5565366726 12071 0ustar downsjuserGNU dbm is a set of database routines that use extendible hashing and works similar to the standard UNIX dbm routines. This is release 1.7.2 of GNU dbm. To compile gdbm: a) configure b) make To compile the optional test and conversion programs: a) make progs To install the basic package: a) make install To install the optional dbm and ndbm compatibility headers: a) make install-compat (You might want to "make -n install" to make sure it will put things were you want them.) Please report bugs to bug-gnu-utils@prep.ai.mit.edu ------------------------------------------ The files are: INSTALL - Installation tips and information. NEWS - New and changed things. COPYING - Copying information. README - This file. bucket.c, extern.h, falloc.c, findkey.c, gdbm.proto, gdbmclose.c, gdbmconst.h gdbmdefs.h, gdbmdelete.c, gdbmerrno.h, gdbmfetch.c, gdbmsync.c, gdbmopen.c, gdbmreorg.c, gdbmseq.c, gdbmstore.c, global.c, gndbm.h, hash.c systems.h, update.c, version.c - Source for GNU dbm library. dbm.h dbminit.c, delete.c, fetch.c, seq.c, store.c - Source for the DBM interface. dbmclose.c, dbmdelete.c, dbmdirfno.c, dbmfetch.c, dbmopen.c, dbmpagfno.c dbmseq.c, dbmstore.c, ndbm.h - Source for the NDBM interface. Makefile - Makefile, will make gdbm.a (BSD and SYSV) testgdbm.c - A simple test program. testdbm.c - A simple test program. testndbm.c - A simple test program. conv2gdbm.c - A dbm database conversion program. gdbm.3, gdbm.texinfo - Documentation for gdbm. The author of GNU dbm may be reached via e-mail to , and the current maintainer may be reached at . E-mail may be sent to either, or both, of these people. ------------------------------------------ Future versions of GDBM may be far, far more UNIX dependant than the library is, currently. If you are/have ported GDBM to non-UNIX like operating systems, please send e-mail to . Please include information about your port, including the type of operating system, your reasons for doing the port, and what changes you have made. gdbm-1.7.2/gdbm.3100600 24413 24 31137 5565362773 12225 0ustar downsjuser.ds ve 1.7.2 .TH GDBM 3 5/15/94 .SH NAME GDBM - The GNU database manager. Includes \fBdbm\fR and \fBndbm\fR compatability. (Version \*(ve.) .SH SYNOPSIS .B #include .PP .SM .B extern gdbm_error .br .B gdbm_errno .PP .B extern char .br .B *gdbm_version .PP .B GDBM_FILE .br .B gdbm_open (name, block_size, read_write, mode, fatal_func) .br .B char * name; .br .B int block_size, read_write, mode; .br .B void (*fatal_func) (); .PP .B void .br .B gdbm_close (dbf) .br .B GDBM_FILE dbf; .PP .B int .br .B gdbm_store (dbf, key, content, flag) .br .B GDBM_FILE dbf; .br .B datum key, content; .br .B int flag; .PP .B datum .br .B gdbm_fetch (dbf, key) .br .B GDBM_FILE dbf; .br .B datum key; .PP .B int .br .B gdbm_delete (dbf, key) .br .B GDBM_FILE dbf; .br .B datum key; .PP .B datum .br .B gdbm_firstkey (dbf) .br .B GDBM_FILE dbf; .PP .B datum .br .B gdbm_nextkey (dbf, key) .br .B GDBM_FILE dbf; .br .B datum key; .PP .B int .br .B gdbm_reorganize (dbf) .br .B GDBM_FILE dbf; .PP .B void .br .B gdbm_sync (dbf) .br .B GDBM_FILE dbf; .PP .B int .br .B gdbm_exists (dbf, key) .br .B GDBM_FILE dbf; .br .B datum key; .PP .B char * .br .B gdbm_strerror (errno) .br .B gdbm_error errno; .PP .B int .br .B gdbm_setopt (dbf, option, value, size) .br .B GDBM_FILE dbf; .br .B int option; .br .B int *value; .br .B int size; .PP .PP .B DBM Compatability routines: .PP .B #include .PP .SM .B int .br .B dbminit (name) .br .B char *name; .PP .B int .br .B store (key, content) .br .B datum key, content; .PP .B datum .br .B fetch (key) .br .B datum key; .PP .B int .br .B delete (key) .br .B datum key; .PP .B datum .br .B firstkey () .PP .B datum .br .B nextkey (key) .br .B datum key; .PP .B int .br .B dbmclose () .PP .PP .B NDBM Compatability routines: .PP .B #include .PP .SM .B DBM .br .B *dbm_open (name, flags, mode) .br .B char *name; .br .B int flags, mode; .PP .B void .br .B dbm_close (file) .br .B DBM *file; .PP .B datum .br .B dbm_fetch (file, key) .br .B DBM *file; .br .B datum key; .PP .B int .br .B dbm_store (file, key, content, flags) .br .B DBM *file; .br .B datum key, content; .br .B int flags; .PP .B int .br .B dbm_delete (file, key) .br .B DBM *file; .br .B datum key; .PP .B datum .br .B dbm_firstkey (file) .br .B DBM *file; .PP .B datum .br .B dbm_nextkey (file) .br .B DBM *file; .PP .B int .br .B dbm_error (file) .br .B DBM *file; .PP .B int .br .B dbm_clearerr (file) .br .B DBM *file; .PP .B int .br .B dbm_pagfno (file) .br .B DBM *file; .PP .B int .br .B dbm_dirfno (file) .br .B DBM *file; .PP .B int .br .B dbm_rdonly (file) .br .B DBM *file; .SH DESCRIPTION GNU dbm is a library of routines that manages data files that contain key/data pairs. The access provided is that of storing, retrieval, and deletion by key and a non-sorted traversal of all keys. A process is allowed to use multiple data files at the same time. A process that opens a gdbm file is designated as a "reader" or a "writer". Only one writer may open a gdbm file and many readers may open the file. Readers and writers can not open the gdbm file at the same time. The procedure for opening a gdbm file is: GDBM_FILE dbf; dbf = gdbm_open ( name, block_size, read_write, mode, fatal_func ) \fIName\fR is the name of the file (the complete name, gdbm does not append any characters to this name). \fIBlock_size\fR is the size of a single transfer from disk to memory. This parameter is ignored unless the file is a new file. The minimum size is 512. If it is less than 512, dbm will use the stat block size for the file system. \fIRead_write\fR can have one of the following values: .br .B GDBM_READER reader .br .B GDBM_WRITER writer .br .B GDBM_WRCREAT writer - if database does not exist create new one .br .B GDBM_NEWDB writer - create new database regardless if one exists .br For the last three (writers of the database) there is an extra value that that can be added to \fIread_write\fR by bitwise or, .B GDBM_FAST. This requests that gdbm write the database with no disk file syncronization. This allows faster writes, but may produce an inconsistant database in the event of abnormal termination of the writer. .br \fIMode\fR is the file mode (see \fBchmod(2)\fR and \fBopen(2)\fR) if the file is created. \fI(*Fatal_func) ()\fR is a function for dbm to call if it detects a fatal error. The only parameter of this function is a string. If the value of 0 is provided, gdbm will use a default function. The return value \fIdbf\fR is the pointer needed by all other routines to access that gdbm file. If the return is the NULL pointer, \fBgdbm_open\fR was not successful. The errors can be found in \fIgdbm_errno\fR for gdbm errors and in \fIerrno\fR for system errors. (For error codes, see gdbmerrno.h.) In all of the following calls, the parameter \fIdbf\fR refers to the pointer returned from \fBgdbm_open\fR. It is important that every file opened is also closed. This is needed to update the reader/writer count on the file. This is done by: gdbm_close (dbf); The database is used by 3 primary routines. The first stores data in the database. ret = gdbm_store ( dbf, key, content, flag ) \fIDbf\fR is the pointer returned by \fBgdbm_open\fR. \fIKey\fR is the key data. \fIContent\fR is the data to be associated with the \fIkey\fR. \fIFlag\fR can have one of the following values: .br .B GDBM_INSERT insert only, generate an error if key exists .br .B GDBM_REPLACE replace contents if key exists. If a reader calls \fBgdbm_store, the return value will be -1. If called with GDBM_INSERT and \fIkey\fR is in the database, the return value will be 1. Otherwise, the return value is 0. \fINOTICE: If you store data for a key that is already in the data base, gdbm replaces the old data with the new data if called with GDBM_REPLACE. You do not get two data items for the same key and you do not get an error from gdbm_store. NOTICE: The size in gdbm is not restricted like dbm or ndbm. Your data can be as large as you want.\fR To search for some data: content = gdbm_fetch ( dbf, key ) \fIDbf\fR is the pointer returned by \fBgdbm_open\fR. \fIKey\fR is the key data. If the \fIdptr\fR element of the return value is NULL, no data was found. Otherwise the return value is a pointer to the found data. The storage space for the \fIdptr\fR element is allocated using \fBmalloc(3C)\fR. \fBGdbm\fI does not automatically free this data. It is the programmer's responsibility to free this storage when it is no longer needed.\fR To search for some data, without retrieving it: ret = gdbm_exists ( dbf, key ) \fIDbf\fR is the pointer returned by \fBgdbm_open\fR. \fIKey\fR is the key data to search for. If the \fIkey\fR is found within the database, the return value \fIret\fR will be true. If nothing appropiate is found, \fIret\fR will be false. This routine is useful for checking for the existance of a record, without performing the memory allocation done by \fBgdbm_fetch\fR. To remove some data from the database: ret = gdbm_delete ( dbf, key ) \fIDbf\fR is the pointer returned by \fBgdbm_open\fR. \fIKey\fR is the key data. The return value is -1 if the item is not present or the requester is a reader. The return value is 0 if there was a successful delete. The next two routines allow for accessing all items in the database. This access is not key sequential, but it is guaranteed to visit every key in the database once. (The order has to do with the hash values.) key = gdbm_firstkey ( dbf ) nextkey = gdbm_nextkey ( dbf, key ) \fIDbf\fR is the pointer returned by \fBgdbm_open\fR. \fIKey\fR is the key data. The return values are both of type \fBdatum\fR. If the \fIdptr\fR element of the return value is NULL, there is no first key or next key. Again notice that \fIdptr\fR points to data allocated by \fBmalloc(3C)\fR and \fBgdbm\fR will not free it for you. These functions were intended to visit the database in read-only algorithms, for instance, to validate the database or similar operations. File `visiting' is based on a `hash table'. \fIgdbm_delete\fR re-arranges the hash table to make sure that any collisions in the table do not leave some item `un-findable'. The original key order is NOT guaranteed to remain unchanged in ALL instances. It is possible that some key will not be visited if a loop like the following is executed: key = gdbm_firstkey ( dbf ); while ( key.dptr ) { nextkey = gdbm_nextkey ( dbf, key ); if ( some condition ) { gdbm_delete ( dbf, key ); free ( key.dptr ); } key = nextkey; } The following routine should be used very infrequently. ret = gdbm_reorganize ( dbf ) If you have had a lot of deletions and would like to shrink the space used by the \fBgdbm\fR file, this routine will reorganize the database. \fBGdbm\fR will not shorten the length of a \fBgdbm\fR file except by using this reorganization. (Deleted file space will be reused.) If you use the \fBGDBM_FAST\fR value in your \fBgdbm_open\fR call, the following routine can be used to guarantee that the database is physically written to the disk file. gdbm_sync ( dbf ) It will not return until the disk file state is syncronized with the in-memory state of the database. To convert a \fBgdbm\fR error code into English text, use this routine: ret = gdbm_strerror ( errno ) Where \fBerrno\fR is of type \fBgdbm_error\fR, usually the global variable \fBgdbm_errno\fR. The appropiate phrase is returned. \fBGdbm\fR now supports the ability to set certain options on an already open database. ret = gdbm_setopt ( dbf, option, value, size ) Where \fBdbf\fR is the return value from a previous call to \fBgdbm_open\fR, and \fBoption\fR specifies which option to set. The valid options are currently: GDBM_CACHESIZE - Set the size of the internal bucket cache. This option may only be set once on each \fBGDBM_FILE\fR descriptor, and is set automatically to 100 upon the first access to the database. GDBM_FASTMODE - Set \fBfast mode\fR to either on or off. This allows \fBfast mode\fR to be toggled on an already open and active database. \fBvalue\fR (see below) should be set to either TRUE or FALSE. \fBvalue\fR is the value to set \fBoption\fR to, specified as an integer pointer. \fBsize\fR is the size of the data pointed to by \fBvalue\fR. The return value will be -1 upon failure, or 0 upon success. The global variable \fBgdbm_errno\fR will be set upon failure. For instance, to set a database to use a cache of 10, after opening it with \fBgdbm_open\fR, but prior to accessing it in any way, the following code could be used: int value = 10; ret = gdbm_setopt( dbf, GDBM_CACHESIZE, &value, sizeof(int)); The following two external variables may be useful: \fBgdbm_errno\fR is the variable that contains more information about gdbm errors. (gdbm.h has the definitions of the error values and defines gdbm_errno as an external variable.) .br \fBgdbm_version\fR is the string containing the version information. There are a few more things of interest. First, \fBgdbm\fR files are not "sparse". You can copy them with the UNIX \fBcp(1)\fR command and they will not expand in the copying process. Also, there is a compatibility mode for use with programs that already use UNIX \fBdbm\fR. In this compatibility mode, no \fRgdbm\fR file pointer is required by the programmer, and only one file may be opened at a time. All users in compatibility mode are assumed to be writers. If the \fBgdbm\fR file is a read only, it will fail as a writer, but will also try to open it as a reader. All returned pointers in datum structures point to data that \fBgdbm\fR WILL free. They should be treated as static pointers (as standard UNIX \fBdbm\fR does). .SH LINKING This library is accessed by specifying \fI-lgdbm\fR as the last parameter to the compile line, e.g.: .sp gcc -o prog prog.c -lgdbm .SH BUGS .SH "SEE ALSO" dbm, ndbm .SH AUTHOR by Philip A. Nelson. Copyright (C) 1990 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: .br e-mail: phil@wwu.edu .br us-mail: Philip A. Nelson .br Computer Science Department .br Western Washington University .br Bellingham, WA 98226 gdbm-1.7.2/gdbm.texinfo100600 24413 24 61765 5565363665 13552 0ustar downsjuser\input texinfo @c -*- Texinfo -*- @comment %**start of header (This is for running Texinfo on a region.) @setfilename gdbm.info @settitle gdbm @c @setchapternewpage odd @comment %**end of header (This is for running Texinfo on a region.) @iftex @finalout @end iftex @ifinfo This file documents the GNU dbm utility. Copyright (C) 1989-1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. @ignore Permission is granted to process this file through Tex and print the results, provided the printed document carries copying permission notice identical to this one except for the removal of this paragraph (this paragraph not being relevant to the printed manual). @end ignore Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions. @end ifinfo @titlepage @null @sp 6 @center @titlefont{GNU dbm} @sp 2 @center A Database Manager @sp 2 @center by Philip A. Nelson @sp 4 @center Manual by Pierre Gaumond and Philip A. Nelson @center Updated by Jason Downs @sp 1 @center Edition 1.4 @sp 1 @center for GNU @code{dbm}, Version 1.7.2. @page @null @vskip 0pt plus 1filll Copyright @copyright{} 1993-94 Free Software Foundation, Inc. @sp 2 This is Edition 1.4 of the @cite{GNU @code{dbm} Manual}, for @code{gdbm} Version 1.7.2. @* Last updated May 15, 1994 Published by the Free Software Foundation @* 675 Massachusetts Avenue, @* Cambridge, MA 02139 USA @* Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Free Software Foundation. @end titlepage @page @node Top, Copying, (dir), (dir) @ifinfo GNU @code{dbm} is a library of functions implementing a hashed database on a disk file. This manual documents GNU @code{dbm} Version 1.7.1 (@code{gdbm}). The software was written by Philip A. Nelson. This document was originally written by Pierre Gaumond from texts written by Phil. @end ifinfo @menu Introduction: * Copying:: Your rights. * Intro:: Introduction to GNU dbm. * List:: List of functions. Functions: * Open:: Opening the database. * Close:: Closing the database. * Store:: Inserting and replacing records in the database. * Fetch:: Searching records in the database. * Delete:: Removing records from the database. * Sequential:: Sequential access to records. * Reorganization:: Database reorganization. * Sync:: Insure all writes to disk have competed. * Errors:: Convert internal error codes into English. * Options:: Setting internal options. Other topics: * Variables:: Two useful variables. * Compatibility:: Compatibility with UNIX dbm and ndbm. * Conversion:: Converting dbm files to gdbm format. * Bugs:: Problems and bugs. @end menu @node Copying, Intro, Top, Top @chapter Copying Conditions. This library is @dfn{free}; this means that everyone is free to use it and free to redistribute it on a free basis. GNU @code{dbm} (@code{gdbm}) is not in the public domain; it is copyrighted and there are restrictions on its distribution, but these restrictions are designed to permit everything that a good cooperating citizen would want to do. What is not allowed is to try to prevent others from further sharing any version of @code{gdbm} that they might get from you.@refill Specifically, we want to make sure that you have the right to give away copies @code{gdbm}, that you receive source code or else can get it if you want it, that you can change these functions or use pieces of them in new free programs, and that you know you can do these things.@refill To make sure that everyone has such rights, we have to forbid you to deprive anyone else of these rights. For example, if you distribute copies @code{gdbm}, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights.@refill Also, for our own protection, we must make certain that everyone finds out that there is no warranty for anything in the @code{gdbm} distribution. If these functions are modified by someone else and passed on, we want their recipients to know that what they have is not what we distributed, so that any problems introduced by others will not reflect on our reputation.@refill @code{gdbm} is currently distributed under the terms of the GNU General Public License, Version 2. (@emph{NOT} under the GNU General Library Public License.) A copy the GNU General Public License is included with the distribution of @code{gdbm}. @node Intro, List, Copying, Top @chapter Introduction to GNU @code{dbm}. GNU @code{dbm} (@code{gdbm})is a library of database functions that use extendible hashing and works similar to the standard UNIX @code{dbm} functions. These routines are provided to a programmer needing to create and manipulate a hashed database. (@code{gdbm} is @emph{NOT} a complete database package for an end user.) The basic use of @code{gdbm} is to store key/data pairs in a data file. Each key must be unique and each key is paired with only one data item. The keys can not be directly accessed in sorted order. The basic unit of data in @code{gdbm} is the structure: @example typedef struct @{ char *dptr; int dsize; @} datum; @end example This structure allows for arbitrary sized keys and data items. The key/data pairs are stored in a @code{gdbm} disk file, called a @code{gdbm} database. An application must open a @code{gdbm} database to be able manipulate the keys and data contained in the database. @code{gdbm} allows an application to have multiple databases open at the same time. When an application opens a @code{gdbm} database, it is designated as a @code{reader} or a @code{writer}. A @code{gdbm} database opened by at most one writer at a time. However, many readers may open the database open simultaneously. Readers and writers can not open the @code{gdbm} database at the same time. @node List, Open, Intro, Top @chapter List of functions. The following is a quick list of the functions contained in the @code{gdbm} library. The include file @code{gdbm.h}, that can be included by the user, contains a definition of these functions. @example #include GDBM_FILE gdbm_open(name, block_size, flags, mode, fatal_func); void gdbm_close(dbf); int gdbm_store(dbf, key, content, flag); datum gdbm_fetch(dbf, key); int gdbm_delete(dbf, key); datum gdbm_firstkey(dbf); datum gdbm_nextkey(dbf, key); int gdbm_reorganize(dbf); void gdbm_sync(dbf); int gdbm_exists(dbf, key); char *gdbm_strerror(errno); int gdbm_setopt(dbf, option, value, size) @end example The @code{gdbm.h} include file is often in the @file{/usr/local/gnu/include} directory. (The actual location of @code{gdbm.h} depends on your local installation of @code{gdbm}.) @node Open, Close, List, Top @chapter Opening the database. Initialize @code{gdbm} system. If the file has a size of zero bytes, a file initialization procedure is performed, setting up the initial structure in the file. The procedure for opening a @code{gdbm} file is: @example GDBM_FILE dbf; dbf = gdbm_open(name, block_size, flags, mode, fatal_func); @end example The parameters are: @table @asis @item char *name The name of the file (the complete name, @code{gdbm} does not append any characters to this name). @item int block_size It is used during initialization to determine the size of various constructs. It is the size of a single transfer from disk to memory. This parameter is ignored if the file has been previously initialized. The minimum size is 512. If the value is less than 512, the file system blocksize is used, otherwise the value of @code{block_size} is used. @item int flags If @code{flags} is set to GDBM_READER, the user wants to just read the database and any call to @code{gdbm_store} or @code{gdbm_delete} will fail. Many readers can access the database at the same time. If @code{flags} is set to GDBM_WRITER, the user wants both read and write access to the database and requires exclusive access. If @code{flags} is set to GDBM_WRCREAT, the user wants both read and write access to the database and if the database does not exist, create a new one. If @code{flags} is set to GDBM_NEWDB, the user want a new database created, regardless of whether one existed, and wants read and write access to the new database. For all writers (GDBM_WRITER, GDBM_WRCREAT and GDBM_NEWDB) the value GDBM_FAST can be added to the @code{flags} field using logical or. This option causes @code{gdbm} to write the database without any disk file synchronization. This allows faster writes, but may produce an inconsistent database in the event of abnormal termination of the writer. Any error detected will cause a return value of NULL and an appropriate value will be in @code{gdbm_errno} (see Variables). If no errors occur, a pointer to the @code{gdbm} file descriptor will be returned. @item int mode File mode (see chmod(2) and open(2) if the file is created). @item void (*fatal_func) () A function for @code{gdbm} to call if it detects a fatal error. The only parameter of this function is a string. If the value of NULL is provided, @code{gdbm} will use a default function. @end table The return value, @code{dbf}, is the pointer needed by all other functions to access that @code{gdbm} file. If the return is the NULL pointer, @code{gdbm_open} was not successful. The errors can be found in @code{gdbm_errno} for @code{gdbm} errors and in @code{errno} for file system errors (for error codes, see @code{gdbm.h}). In all of the following calls, the parameter @code{dbf} refers to the pointer returned from @code{gdbm_open}. @node Close, Store, Open, Top @chapter Closing the database. It is important that every file opened is also closed. This is needed to update the reader/writer count on the file. This is done by: @example gdbm_close(dbf); @end example The parameter is: @table @asis @item GDBM_FILE dbf The pointer returned by @code{gdbm_open}. @end table Closes the @code{gdbm} file and frees all memory associated with the file @code{dbf}. @node Store, Fetch, Close, Top @chapter Inserting and replacing records in the database. The function @code{gdbm_store} inserts or replaces records in the database. @example ret = gdbm_store(dbf, key, content, flag); @end example The parameters are: @table @asis @item GDBM_FILE dbf The pointer returned by @code{gdbm_open}. @item datum key The @code{key} data. @item datum content The data to be associated with the key. @item int flag Defines the action to take when the key is already in the database. The value GDBM_REPLACE (defined in @code{gdbm.h}) asks that the old data be replaced by the new @code{content}. The value GDBM_INSERT asks that an error be returned and no action taken if the @code{key} already exists. @end table The values returned in @code{ret} are: @table @asis @item -1 The item was not stored in the database because the caller was not an official writer or either @code{key} or @code{content} have a NULL dptr field. Both @code{key} and @code{content} must have the dptr field be a non-NULL value. Since a NULL dptr field is used by other functions to indicate an error, a NULL field cannot be valid data. @item +1 The item was not stored because the argument @code{flag} was GDBM_INSERT and the @code{key} was already in the database. @item 0 No error. @code{content} is keyed by @code{key}. The file on disk is updated to reflect the structure of the new database before returning from this function. @end table If you store data for a @code{key} that is already in the data base, @code{gdbm} replaces the old data with the new data if called with GDBM_REPLACE. You do not get two data items for the same @code{key} and you do not get an error from @code{gdbm_store}. The size in @code{gdbm} is not restricted like @code{dbm} or @code{ndbm}. Your data can be as large as you want. @node Fetch, Delete, Store,Top @chapter Searching for records in the database. Looks up a given @code{key} and returns the information associated with that key. The pointer in the structure that is returned is a pointer to dynamically allocated memory block. To search for some data: @example content = gdbm_fetch(dbf, key); @end example The parameters are: @table @asis @item GDBM_FILE dbf The pointer returned by @code{gdbm_open}. @item datum key The @code{key} data. @end table The datum returned in @code{content} is a pointer to the data found. If the dptr is NULL, no data was found. If dptr is not NULL, then it points to data allocated by malloc. @code{gdbm} does not automatically free this data. The user must free this storage when done using it. This eliminates the need to copy the result to save it for later use (you just save the pointer). You may also search for a particular key without retrieving it, using: @example ret = gdbm_exists(dbf, key); @end example The parameters are: @table @asis @item GDBM_FILE dbf The pointer returned by @code{gdbm_open}. @item datum key The @code{key} data. @end table Unlike @code{gdbm_fetch}, this routine does not allocate any memory, and simply returns true or false, depending on whether the @code{key} exists, or not. @node Delete, Sequential, Fetch, Top @chapter Removing records from the database. To remove some data from the database: @example ret = gdbm_delete(dbf, key); @end example The parameters are: @table @asis @item GDBM_FILE dbf The pointer returned by @code{gdbm_open}. @item datum key The @code{key} data. @end table The ret value is -1 if the item is not present or the requester is a reader. The ret value is 0 if there was a successful delete. @code{gdbm_delete} removes the keyed item and the @code{key} from the database @code{dbf}. The file on disk is updated to reflect the structure of the new database before returning from this function. @node Sequential, Reorganization, Delete, Top @chapter Sequential access to records. The next two functions allow for accessing all items in the database. This access is not @code{key} sequential, but it is guaranteed to visit every @code{key} in the database once. The order has to do with the hash values. @code{gdbm_firstkey} starts the visit of all keys in the database. @code{gdbm_nextkey} finds and reads the next entry in the hash structure for @code{dbf}. @example key = gdbm_firstkey(dbf); nextkey = gdbm_nextkey(dbf, key); @end example The parameters are: @table @asis @item GDBM_FILE dbf The pointer returned by @code{gdbm_open}. @item datum @code{key} @item datum nextkey The @code{key} data. @end table The return values are both datum. If @code{key}.dptr or nextkey.dptr is NULL, there is no first @code{key} or next @code{key}. Again notice that dptr points to data allocated by malloc and @code{gdbm} will not free it for you. These functions were intended to visit the database in read-only algorithms, for instance, to validate the database or similar operations. File @code{visiting} is based on a @code{hash table}. @code{gdbm_delete} re-arranges the hash table to make sure that any collisions in the table do not leave some item @code{un-findable}. The original key order is NOT guaranteed to remain unchanged in ALL instances. It is possible that some key will not be visited if a loop like the following is executed: @example @group key = gdbm_firstkey ( dbf ); while ( key.dptr ) @{ nextkey = gdbm_nextkey ( dbf, key ); if ( some condition ) @{ gdbm_delete ( dbf, key ); free ( key.dptr ); @} key = nextkey; @} @end group @end example @node Reorganization, Sync, Sequential, Top @chapter Database reorganization. The following function should be used very seldom. @example ret = gdbm_reorganize(dbf); @end example The parameter is: @table @asis @item GDBM_FILE dbf The pointer returned by @code{gdbm_open}. @end table If you have had a lot of deletions and would like to shrink the space used by the @code{gdbm} file, this function will reorganize the database. @code{gdbm} will not shorten the length of a @code{gdbm} file (deleted file space will be reused) except by using this reorganization. This reorganization requires creating a new file and inserting all the elements in the old file @code{dbf} into the new file. The new file is then renamed to the same name as the old file and @code{dbf} is updated to contain all the correct information about the new file. If an error is detected, the return value is negative. The value zero is returned after a successful reorganization. @node Sync, Errors, Reorganization, Top @chapter Database Synchronization If your database was opened with the GDBM_FAST flag, @code{gdbm} does not wait for writes to the disk to complete before continuing. This allows faster writing of databases at the risk of having a corrupted database if the application terminates in an abnormal fashion. The following function allows the programmer to make sure the disk version of the database has been completely updated with all changes to the current time. @example gdbm_sync(dbf); @end example The parameter is: @table @asis @item GDBM_FILE dbf The pointer returned by @code{gdbm_open}. @end table This would usually be called after a complete set of changes have been made to the database and before some long waiting time. @code{gdbm_close} automatically calls the equivalent of @code{gdbm_sync} so no call is needed if the database is to be closed immediately after the set of changes have been made. @node Errors, Options, Sync, Top @chapter Error strings. To convert a @code{gdbm} error code into English text, use this routine: @example ret = gdbm_strerror(errno) @end example The parameter is: @table @asis @item gdbm_error errno The @code{gdbm} error code, usually @code{gdbm_errno}. @end table The appropiate phrase for reading by humans is returned. @node Options, Variables, Errors, top @chapter Seting options. @code{Gdbm} now supports the ability to set certain options on an already open database. @example ret = gdbm_setopt(dbf, option, value, size) @end example The parameters are: @table @asis @item GDBM_FILE dbf The pointer returned by @code{gdbm_open}. @item int option The option to be set. @item int *value A pointer to the value to which @code{option} will be set. @item int size The length of the data pointed to by @code{value}. @end table The valid options are currently: GDBM_CACHESIZE - Set the size of the internal bucket cache. This option may only be set once on each GDBM_FILE descriptor, and is set automatically to 100 upon the first access to the database. GDBM_FASTMODE - Set fast mode to either on or off. This allows fast mode to be toggled on an already open and active database. value (see below) should be set to either TRUE or FALSE. The return value will be -1 upon failure, or 0 upon success. The global variable @code{gdbm_errno} will be set upon failure. For instance, to set a database to use a cache of 10, after opening it with @code{gdbm_open}, but prior to accessing it in any way, the following code could be used: @example int value = 10; ret = gdbm_setopt(dbf, GDBM_CACHESIZE, &value, sizeof(int)); @end example @node Variables, Compatibility, Options, Top @chapter Two useful variables. The following two variables are variables that may need to be used: @table @asis @item gdbm_error gdbm_errno The variable that contains more information about @code{gdbm} errors (@code{gdbm.h} has the definitions of the error values). @item char * gdbm_version The string containing the version information. @end table @node Compatibility, Conversion, Variables, Top @chapter Compatibility with standard @code{dbm} and @code{ndbm}. GNU @code{dbm} files are not @code{sparse}. You can copy them with the UNIX @code{cp} command and they will not expand in the copying process. There is a compatibility mode for use with programs that already use UNIX @code{dbm} and UNIX @code{ndbm}. GNU @code{dbm} has compatibility functions for @code{dbm}. For @code{dbm} compatibility functions, you need the include file @code{dbm.h}. In this compatibility mode, no @code{gdbm} file pointer is required by the user, and Only one file may be opened at a time. All users in compatibility mode are assumed to be writers. If the @code{gdbm} file is a read only, it will fail as a writer, but will also try to open it as a reader. All returned pointers in datum structures point to data that @code{gdbm} WILL free. They should be treated as static pointers (as standard UNIX @code{dbm} does). The compatibility function names are the same as the UNIX @code{dbm} function names. Their definitions follow: @example int dbminit(name); int store(key, content); datum fetch(key); int delete(key); datum firstkey(); datum nextkey(key); int dbmclose(); @end example Standard UNIX @code{dbm} and GNU @code{dbm} do not have the same data format in the file. You cannot access a standard UNIX @code{dbm} file with GNU @code{dbm}! If you want to use an old database with GNU @code{dbm}, you must use the @code{conv2gdbm} program. Also, GNU @code{dbm} has compatibility functions for @code{ndbm}. For @code{ndbm} compatibility functions, you need the include file @code{ndbm.h}. Again, just like @code{ndbm}, any returned datum can be assumed to be static storage. You do not have to free that memory, the @code{ndbm} compatibility functions will do it for you. The functions are: @example DBM *dbm_open(name, flags, mode); void dbm_close(file); datum dbm_fetch(file, key); int dbm_store(file, key, @code{content}, flags); int dbm_delete(file, key); datum dbm_firstkey(file); datum dbm_nextkey(file); int dbm_error(file); int dbm_clearerr(file); int dbm_dirfno(file); int dbm_pagfno(file); int dbm_rdonly(file); @end example If you want to compile an old C program that used UNIX @code{dbm} or @code{ndbm} and want to use @code{gdbm} files, execute the following @code{cc} command: @example cc ... -L /usr/local/lib -lgdbm @end example @node Conversion, Bugs, Compatibility, Top @chapter Converting @code{dbm} files to @code{gdbm} format. The program @code{conv2gdbm} has been provided to help you convert from @code{dbm} databases to @code{gdbm}. The usage is: @example conv2gdbm [-q] [-b block_size] dbm_file [gdbm_file] @end example The options are: @table @asis @item -q Causes @code{conv2gdbm} to work quietly. @item block_size Is the same as in @code{gdbm_open}. @item dbm_file Is the name of the @code{dbm} file without the @code{.pag} or @code{.dir} extensions. @item gdbm_file Is the complete file name. If not included, the @code{gdbm} file name is the same as the @code{dbm} file name without any extensions. That is @code{conv2gdbm} @code{dbmfile} converts the files @code{dbmfile.pag} and @code{dbmfile.dir} into a @code{gdbm} file called @code{dbmfile}. @end table @node Bugs, , Conversion, Top @chapter Problems and bugs. If you have problems with GNU @code{dbm} or think you've found a bug, please report it. Before reporting a bug, make sure you've actually found a real bug. Carefully reread the documentation and see if it really says you can do what you're trying to do. If it's not clear whether you should be able to do something or not, report that too; it's a bug in the documentation! Before reporting a bug or trying to fix it yourself, try to isolate it to the smallest possible input file that reproduces the problem. Then send us the input file and the exact results @code{gdbm} gave you. Also say what you expected to occur; this will help us decide whether the problem was really in the documentation. Once you've got a precise problem, send e-mail to: @example Internet: @file{bug-gnu-utils@@prep.ai.mit.edu}. UUCP: @file{mit-eddie!prep.ai.mit.edu!bug-gnu-utils}. @end example Please include the version number of GNU @code{dbm} you are using. You can get this information by printing the variable @code{gdbm_version} (see Variables). Non-bug suggestions are always welcome as well. If you have questions about things that are unclear in the documentation or are just obscure features, please report them too. You may contact the author by: @example e-mail: phil@@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 @end example @bye gdbm-1.7.2/gdbm.info100600 24413 24 57106 5565366234 13016 0ustar downsjuserThis is Info file gdbm.info, produced by Makeinfo-1.55 from the input file ./gdbm.texinfo. This file documents the GNU dbm utility. Copyright (C) 1989-1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions.  File: gdbm.info, Node: Top, Next: Copying, Prev: (dir), Up: (dir) GNU `dbm' is a library of functions implementing a hashed database on a disk file. This manual documents GNU `dbm' Version 1.7.1 (`gdbm'). The software was written by Philip A. Nelson. This document was originally written by Pierre Gaumond from texts written by Phil. * Menu: Introduction: * Copying:: Your rights. * Intro:: Introduction to GNU dbm. * List:: List of functions. Functions: * Open:: Opening the database. * Close:: Closing the database. * Store:: Inserting and replacing records in the database. * Fetch:: Searching records in the database. * Delete:: Removing records from the database. * Sequential:: Sequential access to records. * Reorganization:: Database reorganization. * Sync:: Insure all writes to disk have competed. * Errors:: Convert internal error codes into English. * Options:: Setting internal options. Other topics: * Variables:: Two useful variables. * Compatibility:: Compatibility with UNIX dbm and ndbm. * Conversion:: Converting dbm files to gdbm format. * Bugs:: Problems and bugs.  File: gdbm.info, Node: Copying, Next: Intro, Prev: Top, Up: Top Copying Conditions. ******************* This library is "free"; this means that everyone is free to use it and free to redistribute it on a free basis. GNU `dbm' (`gdbm') is not in the public domain; it is copyrighted and there are restrictions on its distribution, but these restrictions are designed to permit everything that a good cooperating citizen would want to do. What is not allowed is to try to prevent others from further sharing any version of `gdbm' that they might get from you. Specifically, we want to make sure that you have the right to give away copies `gdbm', that you receive source code or else can get it if you want it, that you can change these functions or use pieces of them in new free programs, and that you know you can do these things. To make sure that everyone has such rights, we have to forbid you to deprive anyone else of these rights. For example, if you distribute copies `gdbm', you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights. Also, for our own protection, we must make certain that everyone finds out that there is no warranty for anything in the `gdbm' distribution. If these functions are modified by someone else and passed on, we want their recipients to know that what they have is not what we distributed, so that any problems introduced by others will not reflect on our reputation. `gdbm' is currently distributed under the terms of the GNU General Public License, Version 2. (*NOT* under the GNU General Library Public License.) A copy the GNU General Public License is included with the distribution of `gdbm'.  File: gdbm.info, Node: Intro, Next: List, Prev: Copying, Up: Top Introduction to GNU `dbm'. ************************** GNU `dbm' (`gdbm')is a library of database functions that use extendible hashing and works similar to the standard UNIX `dbm' functions. These routines are provided to a programmer needing to create and manipulate a hashed database. (`gdbm' is *NOT* a complete database package for an end user.) The basic use of `gdbm' is to store key/data pairs in a data file. Each key must be unique and each key is paired with only one data item. The keys can not be directly accessed in sorted order. The basic unit of data in `gdbm' is the structure: typedef struct { char *dptr; int dsize; } datum; This structure allows for arbitrary sized keys and data items. The key/data pairs are stored in a `gdbm' disk file, called a `gdbm' database. An application must open a `gdbm' database to be able manipulate the keys and data contained in the database. `gdbm' allows an application to have multiple databases open at the same time. When an application opens a `gdbm' database, it is designated as a `reader' or a `writer'. A `gdbm' database opened by at most one writer at a time. However, many readers may open the database open simultaneously. Readers and writers can not open the `gdbm' database at the same time.  File: gdbm.info, Node: List, Next: Open, Prev: Intro, Up: Top List of functions. ****************** The following is a quick list of the functions contained in the `gdbm' library. The include file `gdbm.h', that can be included by the user, contains a definition of these functions. #include GDBM_FILE gdbm_open(name, block_size, flags, mode, fatal_func); void gdbm_close(dbf); int gdbm_store(dbf, key, content, flag); datum gdbm_fetch(dbf, key); int gdbm_delete(dbf, key); datum gdbm_firstkey(dbf); datum gdbm_nextkey(dbf, key); int gdbm_reorganize(dbf); void gdbm_sync(dbf); int gdbm_exists(dbf, key); char *gdbm_strerror(errno); int gdbm_setopt(dbf, option, value, size) The `gdbm.h' include file is often in the `/usr/local/gnu/include' directory. (The actual location of `gdbm.h' depends on your local installation of `gdbm'.)  File: gdbm.info, Node: Open, Next: Close, Prev: List, Up: Top Opening the database. ********************* Initialize `gdbm' system. If the file has a size of zero bytes, a file initialization procedure is performed, setting up the initial structure in the file. The procedure for opening a `gdbm' file is: GDBM_FILE dbf; dbf = gdbm_open(name, block_size, flags, mode, fatal_func); The parameters are: char *name The name of the file (the complete name, `gdbm' does not append any characters to this name). int block_size It is used during initialization to determine the size of various constructs. It is the size of a single transfer from disk to memory. This parameter is ignored if the file has been previously initialized. The minimum size is 512. If the value is less than 512, the file system blocksize is used, otherwise the value of `block_size' is used. int flags If `flags' is set to GDBM_READER, the user wants to just read the database and any call to `gdbm_store' or `gdbm_delete' will fail. Many readers can access the database at the same time. If `flags' is set to GDBM_WRITER, the user wants both read and write access to the database and requires exclusive access. If `flags' is set to GDBM_WRCREAT, the user wants both read and write access to the database and if the database does not exist, create a new one. If `flags' is set to GDBM_NEWDB, the user want a new database created, regardless of whether one existed, and wants read and write access to the new database. For all writers (GDBM_WRITER, GDBM_WRCREAT and GDBM_NEWDB) the value GDBM_FAST can be added to the `flags' field using logical or. This option causes `gdbm' to write the database without any disk file synchronization. This allows faster writes, but may produce an inconsistent database in the event of abnormal termination of the writer. Any error detected will cause a return value of NULL and an appropriate value will be in `gdbm_errno' (see Variables). If no errors occur, a pointer to the `gdbm' file descriptor will be returned. int mode File mode (see chmod(2) and open(2) if the file is created). void (*fatal_func) () A function for `gdbm' to call if it detects a fatal error. The only parameter of this function is a string. If the value of NULL is provided, `gdbm' will use a default function. The return value, `dbf', is the pointer needed by all other functions to access that `gdbm' file. If the return is the NULL pointer, `gdbm_open' was not successful. The errors can be found in `gdbm_errno' for `gdbm' errors and in `errno' for file system errors (for error codes, see `gdbm.h'). In all of the following calls, the parameter `dbf' refers to the pointer returned from `gdbm_open'.  File: gdbm.info, Node: Close, Next: Store, Prev: Open, Up: Top Closing the database. ********************* It is important that every file opened is also closed. This is needed to update the reader/writer count on the file. This is done by: gdbm_close(dbf); The parameter is: GDBM_FILE dbf The pointer returned by `gdbm_open'. Closes the `gdbm' file and frees all memory associated with the file `dbf'.  File: gdbm.info, Node: Store, Next: Fetch, Prev: Close, Up: Top Inserting and replacing records in the database. ************************************************ The function `gdbm_store' inserts or replaces records in the database. ret = gdbm_store(dbf, key, content, flag); The parameters are: GDBM_FILE dbf The pointer returned by `gdbm_open'. datum key The `key' data. datum content The data to be associated with the key. int flag Defines the action to take when the key is already in the database. The value GDBM_REPLACE (defined in `gdbm.h') asks that the old data be replaced by the new `content'. The value GDBM_INSERT asks that an error be returned and no action taken if the `key' already exists. The values returned in `ret' are: -1 The item was not stored in the database because the caller was not an official writer or either `key' or `content' have a NULL dptr field. Both `key' and `content' must have the dptr field be a non-NULL value. Since a NULL dptr field is used by other functions to indicate an error, a NULL field cannot be valid data. +1 The item was not stored because the argument `flag' was GDBM_INSERT and the `key' was already in the database. 0 No error. `content' is keyed by `key'. The file on disk is updated to reflect the structure of the new database before returning from this function. If you store data for a `key' that is already in the data base, `gdbm' replaces the old data with the new data if called with GDBM_REPLACE. You do not get two data items for the same `key' and you do not get an error from `gdbm_store'. The size in `gdbm' is not restricted like `dbm' or `ndbm'. Your data can be as large as you want.  File: gdbm.info, Node: Fetch, Next: Delete, Prev: Store, Up: Top Searching for records in the database. ************************************** Looks up a given `key' and returns the information associated with that key. The pointer in the structure that is returned is a pointer to dynamically allocated memory block. To search for some data: content = gdbm_fetch(dbf, key); The parameters are: GDBM_FILE dbf The pointer returned by `gdbm_open'. datum key The `key' data. The datum returned in `content' is a pointer to the data found. If the dptr is NULL, no data was found. If dptr is not NULL, then it points to data allocated by malloc. `gdbm' does not automatically free this data. The user must free this storage when done using it. This eliminates the need to copy the result to save it for later use (you just save the pointer). You may also search for a particular key without retrieving it, using: ret = gdbm_exists(dbf, key); The parameters are: GDBM_FILE dbf The pointer returned by `gdbm_open'. datum key The `key' data. Unlike `gdbm_fetch', this routine does not allocate any memory, and simply returns true or false, depending on whether the `key' exists, or not.  File: gdbm.info, Node: Delete, Next: Sequential, Prev: Fetch, Up: Top Removing records from the database. *********************************** To remove some data from the database: ret = gdbm_delete(dbf, key); The parameters are: GDBM_FILE dbf The pointer returned by `gdbm_open'. datum key The `key' data. The ret value is -1 if the item is not present or the requester is a reader. The ret value is 0 if there was a successful delete. `gdbm_delete' removes the keyed item and the `key' from the database `dbf'. The file on disk is updated to reflect the structure of the new database before returning from this function.  File: gdbm.info, Node: Sequential, Next: Reorganization, Prev: Delete, Up: Top Sequential access to records. ***************************** The next two functions allow for accessing all items in the database. This access is not `key' sequential, but it is guaranteed to visit every `key' in the database once. The order has to do with the hash values. `gdbm_firstkey' starts the visit of all keys in the database. `gdbm_nextkey' finds and reads the next entry in the hash structure for `dbf'. key = gdbm_firstkey(dbf); nextkey = gdbm_nextkey(dbf, key); The parameters are: GDBM_FILE dbf The pointer returned by `gdbm_open'. datum `key' datum nextkey The `key' data. The return values are both datum. If `key'.dptr or nextkey.dptr is NULL, there is no first `key' or next `key'. Again notice that dptr points to data allocated by malloc and `gdbm' will not free it for you. These functions were intended to visit the database in read-only algorithms, for instance, to validate the database or similar operations. File `visiting' is based on a `hash table'. `gdbm_delete' re-arranges the hash table to make sure that any collisions in the table do not leave some item `un-findable'. The original key order is NOT guaranteed to remain unchanged in ALL instances. It is possible that some key will not be visited if a loop like the following is executed: key = gdbm_firstkey ( dbf ); while ( key.dptr ) { nextkey = gdbm_nextkey ( dbf, key ); if ( some condition ) { gdbm_delete ( dbf, key ); free ( key.dptr ); } key = nextkey; }  File: gdbm.info, Node: Reorganization, Next: Sync, Prev: Sequential, Up: Top Database reorganization. ************************ The following function should be used very seldom. ret = gdbm_reorganize(dbf); The parameter is: GDBM_FILE dbf The pointer returned by `gdbm_open'. If you have had a lot of deletions and would like to shrink the space used by the `gdbm' file, this function will reorganize the database. `gdbm' will not shorten the length of a `gdbm' file (deleted file space will be reused) except by using this reorganization. This reorganization requires creating a new file and inserting all the elements in the old file `dbf' into the new file. The new file is then renamed to the same name as the old file and `dbf' is updated to contain all the correct information about the new file. If an error is detected, the return value is negative. The value zero is returned after a successful reorganization.  File: gdbm.info, Node: Sync, Next: Errors, Prev: Reorganization, Up: Top Database Synchronization ************************ If your database was opened with the GDBM_FAST flag, `gdbm' does not wait for writes to the disk to complete before continuing. This allows faster writing of databases at the risk of having a corrupted database if the application terminates in an abnormal fashion. The following function allows the programmer to make sure the disk version of the database has been completely updated with all changes to the current time. gdbm_sync(dbf); The parameter is: GDBM_FILE dbf The pointer returned by `gdbm_open'. This would usually be called after a complete set of changes have been made to the database and before some long waiting time. `gdbm_close' automatically calls the equivalent of `gdbm_sync' so no call is needed if the database is to be closed immediately after the set of changes have been made.  File: gdbm.info, Node: Errors, Next: Options, Prev: Sync, Up: Top Error strings. ************** To convert a `gdbm' error code into English text, use this routine: ret = gdbm_strerror(errno) The parameter is: gdbm_error errno The `gdbm' error code, usually `gdbm_errno'. The appropiate phrase for reading by humans is returned.  File: gdbm.info, Node: Options, Next: Variables, Prev: Errors, Up: Top Seting options. *************** `Gdbm' now supports the ability to set certain options on an already open database. ret = gdbm_setopt(dbf, option, value, size) The parameters are: GDBM_FILE dbf The pointer returned by `gdbm_open'. int option The option to be set. int *value A pointer to the value to which `option' will be set. int size The length of the data pointed to by `value'. The valid options are currently: GDBM_CACHESIZE - Set the size of the internal bucket cache. This option may only be set once on each GDBM_FILE descriptor, and is set automatically to 100 upon the first access to the database. GDBM_FASTMODE - Set fast mode to either on or off. This allows fast mode to be toggled on an already open and active database. value (see below) should be set to either TRUE or FALSE. The return value will be -1 upon failure, or 0 upon success. The global variable `gdbm_errno' will be set upon failure. For instance, to set a database to use a cache of 10, after opening it with `gdbm_open', but prior to accessing it in any way, the following code could be used: int value = 10; ret = gdbm_setopt(dbf, GDBM_CACHESIZE, &value, sizeof(int));  File: gdbm.info, Node: Variables, Next: Compatibility, Prev: Options, Up: Top Two useful variables. ********************* The following two variables are variables that may need to be used: gdbm_error gdbm_errno The variable that contains more information about `gdbm' errors (`gdbm.h' has the definitions of the error values). char * gdbm_version The string containing the version information.  File: gdbm.info, Node: Compatibility, Next: Conversion, Prev: Variables, Up: Top Compatibility with standard `dbm' and `ndbm'. ********************************************* GNU `dbm' files are not `sparse'. You can copy them with the UNIX `cp' command and they will not expand in the copying process. There is a compatibility mode for use with programs that already use UNIX `dbm' and UNIX `ndbm'. GNU `dbm' has compatibility functions for `dbm'. For `dbm' compatibility functions, you need the include file `dbm.h'. In this compatibility mode, no `gdbm' file pointer is required by the user, and Only one file may be opened at a time. All users in compatibility mode are assumed to be writers. If the `gdbm' file is a read only, it will fail as a writer, but will also try to open it as a reader. All returned pointers in datum structures point to data that `gdbm' WILL free. They should be treated as static pointers (as standard UNIX `dbm' does). The compatibility function names are the same as the UNIX `dbm' function names. Their definitions follow: int dbminit(name); int store(key, content); datum fetch(key); int delete(key); datum firstkey(); datum nextkey(key); int dbmclose(); Standard UNIX `dbm' and GNU `dbm' do not have the same data format in the file. You cannot access a standard UNIX `dbm' file with GNU `dbm'! If you want to use an old database with GNU `dbm', you must use the `conv2gdbm' program. Also, GNU `dbm' has compatibility functions for `ndbm'. For `ndbm' compatibility functions, you need the include file `ndbm.h'. Again, just like `ndbm', any returned datum can be assumed to be static storage. You do not have to free that memory, the `ndbm' compatibility functions will do it for you. The functions are: DBM *dbm_open(name, flags, mode); void dbm_close(file); datum dbm_fetch(file, key); int dbm_store(file, key, `content', flags); int dbm_delete(file, key); datum dbm_firstkey(file); datum dbm_nextkey(file); int dbm_error(file); int dbm_clearerr(file); int dbm_dirfno(file); int dbm_pagfno(file); int dbm_rdonly(file); If you want to compile an old C program that used UNIX `dbm' or `ndbm' and want to use `gdbm' files, execute the following `cc' command: cc ... -L /usr/local/lib -lgdbm  File: gdbm.info, Node: Conversion, Next: Bugs, Prev: Compatibility, Up: Top Converting `dbm' files to `gdbm' format. **************************************** The program `conv2gdbm' has been provided to help you convert from `dbm' databases to `gdbm'. The usage is: conv2gdbm [-q] [-b block_size] dbm_file [gdbm_file] The options are: -q Causes `conv2gdbm' to work quietly. block_size Is the same as in `gdbm_open'. dbm_file Is the name of the `dbm' file without the `.pag' or `.dir' extensions. gdbm_file Is the complete file name. If not included, the `gdbm' file name is the same as the `dbm' file name without any extensions. That is `conv2gdbm' `dbmfile' converts the files `dbmfile.pag' and `dbmfile.dir' into a `gdbm' file called `dbmfile'.  File: gdbm.info, Node: Bugs, Prev: Conversion, Up: Top Problems and bugs. ****************** If you have problems with GNU `dbm' or think you've found a bug, please report it. Before reporting a bug, make sure you've actually found a real bug. Carefully reread the documentation and see if it really says you can do what you're trying to do. If it's not clear whether you should be able to do something or not, report that too; it's a bug in the documentation! Before reporting a bug or trying to fix it yourself, try to isolate it to the smallest possible input file that reproduces the problem. Then send us the input file and the exact results `gdbm' gave you. Also say what you expected to occur; this will help us decide whether the problem was really in the documentation. Once you've got a precise problem, send e-mail to: Internet: `bug-gnu-utils@prep.ai.mit.edu'. UUCP: `mit-eddie!prep.ai.mit.edu!bug-gnu-utils'. Please include the version number of GNU `dbm' you are using. You can get this information by printing the variable `gdbm_version' (see Variables). Non-bug suggestions are always welcome as well. If you have questions about things that are unclear in the documentation or are just obscure features, please report them too. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226  Tag Table: Node: Top767 Node: Copying2197 Node: Intro3979 Node: List5395 Node: Open6324 Node: Close9217 Node: Store9652 Node: Fetch11447 Node: Delete12696 Node: Sequential13362 Node: Reorganization15044 Node: Sync15999 Node: Errors16959 Node: Options17319 Node: Variables18625 Node: Compatibility19049 Node: Conversion21423 Node: Bugs22237  End Tag Table gdbm-1.7.2/NEWS100600 24413 24 4533 5565360351 11675 0ustar downsjuserCHANGES from 1.7.1 to 1.7.2 1. Enhanced portability and compile/installation changes. 2. Additional, "fast mode" related gdbm_setopt() option. 3. Growth problems bug fix. CHANGES from 1.7 to 1.7.1 1. Enhanced portabilty and compile/installation bug fixes. 2. Switched over to using an auto config header. 2. Slight documentation upgrade. CHANGES from 1.6 to 1.7 1. A new dynamic, delayed initialization, bucket cache. 2. New gdbm_setopt(), gdbm_exists(), and gdbm_strerror() routines. 3. Slightly improved dbm/ndbm compatibility. 4. Greatly improved portability to 64 or 16 bit machines. 5. Various bug fixes. CHANGES from 1.5 to 1.6 1. New documentation in both man and texinfo formats. 2. Bug fixes. 3. A New "writers" mode that does not fsync the database. 4. Uses Autoconf now. CHANGES from 1.4 to 1.5: 1. Minor bug fixes. See the ChangeLog. 2. Added gdbmconst.h to allow users to change the size of the bucket cache in the systems.h file. CHANGES from 1.0 to 1.4: 1. Mainly bug fixes. 2. A define for "dbmclose()" was added to dbm.h for those few implementaions that need that call. 3. For details, see the ChangeLog. CHANGES from 0.9 to 1.0: 1. Makefiles were combined into one and a few new things added to it. 2. Several minor bugs were fixed including a cache bug. 3. Two new calls (dbm_pagfno, dbm_dirfno) were added to the NDBM interface. 3. A conversion program from dbm files to gdbm files was added. 4. Reorganize was changed to allow complex file names. (dir/file form) 5. testgdbm, testndbm, and testdbm were modified to return key and data pairs where needed and to take an optional file name as an argument. testgdbm had some command characters changed. 6. The DBM and NDBM interfaces were separated. 7. An include file for dbm users was added. (dbm.h) 8. The include file for ndbm users was renamed ndbm.h. (It was gndbm.h.) CHANGES from 0.8 to 0.9: 1. The hash function changed. 2. The file format changed. 3. There was a complete rewrite of falloc.c. 4. There were added compatiblity routines for ndbm. 5. The file names for dbm compatibility routines were made to look like dbm. 6. Test programs changed. 7. Support for System V. 8. Various other small changes. 9. The need for recovery and associated code was removed. gdbm-1.7.2/INSTALL100600 24413 24 15550 5464213377 12253 0ustar downsjuserInstallation Notes SunOS: The SunOS stock compiler returns structures in a manner different from the method GCC uses. If you are compiling this library using GCC, and are linking in any other libraries that return structures and are not compiled with GCC (such as system libraries), you must compile this library, and your entire application, with the -fpcc-struct-return flag. On the other hand, if you are certain that this library will *never* be linked with anything compiled with anything other than normal GCC, it is safe to compile without the flag. If you're using pure stock Sun CC, disregard the above. alloca: GDBM uses alloca, heavily. If your machine does not support alloca, GDBM will provide one, and embed it within the library. Depending on your application, this is not always a good thing, and you must remove the alloca.c and alloca.o references from the configured Makefile if you wish this not to take place. ndbm/dbm: Some systems do not have a default dbm or ndbm library. On such systems, some of the test and/or conversion programs included in this distribution will fail to compile. This is purposeful, since without default system libraries, there is nothing to test or convert from. -------- This is a generic INSTALL file for utilities distributions. If this package does not come with, e.g., installable documentation or data files, please ignore the references to them below. To compile this package: 1. Configure the package for your system. In the directory that this file is in, type `./configure'. If you're using `csh' on an old version of System V, you might need to type `sh configure' instead to prevent `csh' from trying to execute `configure' itself. The `configure' shell script attempts to guess correct values for various system-dependent variables used during compilation, and creates the Makefile(s) (one in each subdirectory of the source directory). In some packages it creates a C header file containing system-dependent definitions. It also creates a file `config.status' that you can run in the future to recreate the current configuration. Running `configure' takes a minute or two. While it is running, it prints some messages that tell what it is doing. If you don't want to see the messages, run `configure' with its standard output redirected to `/dev/null'; for example, `./configure >/dev/null'. To compile the package in a different directory from the one containing the source code, you must use a version of `make' that supports the VPATH variable, such as GNU `make'. `cd' to the directory where you want the object files and executables to go and run `configure'. `configure' automatically checks for the source code in the directory that `configure' is in and in `..'. If for some reason `configure' is not in the source code directory that you are configuring, then it will report that it can't find the source code. In that case, run `configure' with the option `--srcdir=DIR', where DIR is the directory that contains the source code. By default, `make install' will install the package's files in /usr/local/bin, /usr/local/lib, /usr/local/man, etc. You can specify an installation prefix other than /usr/local by giving `configure' the option `--prefix=PATH'. Alternately, you can do so by consistently giving a value for the `prefix' variable when you run `make', e.g., make prefix=/usr/gnu make prefix=/usr/gnu install You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you give `configure' the option `--exec-prefix=PATH' or set the `make' variable `exec_prefix' to PATH, the package will use PATH as the prefix for installing programs and libraries. Data files and documentation will still use the regular prefix. Normally, all files are installed using the regular prefix. Another `configure' option is useful mainly in `Makefile' rules for updating `config.status' and `Makefile'. The `--no-create' option figures out the configuration for your system and records it in `config.status', without actually configuring the package (creating `Makefile's and perhaps a configuration header file). Later, you can run `./config.status' to actually configure the package. You can also give `config.status' the `--recheck' option, which makes it re-run `configure' with the same arguments you used before. This option is useful if you change `configure'. Some packages pay attention to `--with-PACKAGE' options to `configure', where PACKAGE is something like `gnu-libc' or `x' (for the X Window System). The README should mention any --with- options that the package recognizes. `configure' ignores any other arguments that you give it. If your system requires unusual options for compilation or linking that `configure' doesn't know about, you can give `configure' initial values for some variables by setting them in the environment. In Bourne-compatible shells, you can do that on the command line like this: CC='gcc -traditional' DEFS=-D_POSIX_SOURCE ./configure The `make' variables that you might want to override with environment variables when running `configure' are: (For these variables, any value given in the environment overrides the value that `configure' would choose:) CC C compiler program. Default is `cc', or `gcc' if `gcc' is in your PATH. INSTALL Program to use to install files. Default is `install' if you have it, `cp' otherwise. (For these variables, any value given in the environment is added to the value that `configure' chooses:) DEFS Configuration options, in the form `-Dfoo -Dbar ...' Do not use this variable in packages that create a configuration header file. LIBS Libraries to link with, in the form `-lfoo -lbar ...' If you need to do unusual things to compile the package, we encourage you to figure out how `configure' could check whether to do them, and mail diffs or instructions to the address given in the README so we can include them in the next release. 2. Type `make' to compile the package. If you want, you can override the `make' variables CFLAGS and LDFLAGS like this: make CFLAGS=-O2 LDFLAGS=-s 3. If the package comes with self-tests and you want to run them, type `make check'. If you're not sure whether there are any, try it; if `make' responds with something like make: *** No way to make target `check'. Stop. then the package does not come with self-tests. 4. Type `make install' to install programs, data files, and documentation. 5. You can remove the program binaries and object files from the source directory by typing `make clean'. To also remove the Makefile(s), the header file containing system-dependent definitions (if the package uses one), and `config.status' (all the files that `configure' created), type `make distclean'. The file `configure.in' is used as a template to create `configure' by a program called `autoconf'. You will only need it if you want to regenerate `configure' using a newer version of `autoconf'. gdbm-1.7.2/gdbm.proto100600 24413 24 7173 5464442724 13202 0ustar downsjuser/* gdbm.h - The include file for dbm users. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* Protection for multiple includes. */ #ifndef _GDBM_H_ #define _GDBM_H_ /* Parameters to gdbm_open for READERS, WRITERS, and WRITERS who can create the database. */ #define GDBM_READER 0 /* A reader. */ #define GDBM_WRITER 1 /* A writer. */ #define GDBM_WRCREAT 2 /* A writer. Create the db if needed. */ #define GDBM_NEWDB 3 /* A writer. Always create a new db. */ #define GDBM_FAST 16 /* Write fast! => No fsyncs. */ /* Parameters to gdbm_store for simple insertion or replacement in the case that the key is already in the database. */ #define GDBM_INSERT 0 /* Never replace old data with new. */ #define GDBM_REPLACE 1 /* Always replace old data with new. */ /* Parameters to gdbm_setopt, specifing the type of operation to perform. */ #define GDBM_CACHESIZE 1 /* Set the cache size. */ /* The data and key structure. This structure is defined for compatibility. */ typedef struct { char *dptr; int dsize; } datum; /* The file information header. This is good enough for most applications. */ typedef struct {int dummy[10];} *GDBM_FILE; /* Determine if the C(++) compiler requires complete function prototype */ #if __STDC__ || defined(__cplusplus) || defined(c_plusplus) #define GDBM_Proto(x) x #else #define GDBM_Proto(x) () #endif /* NeedFunctionPrototypes */ /* External variable, the gdbm build release string. */ extern char *gdbm_version; /* GDBM C++ support */ #if defined(__cplusplus) || defined(c_plusplus) extern "C" { #endif /* These are the routines! */ extern GDBM_FILE gdbm_open GDBM_Proto(( char *file, int block_size, int flags, int mode, void (*fatal_func)() )); extern void gdbm_close GDBM_Proto(( GDBM_FILE dbf )); extern int gdbm_store GDBM_Proto(( GDBM_FILE dbf, datum key, datum content, int flags )); extern datum gdbm_fetch GDBM_Proto(( GDBM_FILE dbf, datum key )); extern int gdbm_delete GDBM_Proto(( GDBM_FILE dbf, datum key )); extern datum gdbm_firstkey GDBM_Proto(( GDBM_FILE dbf )); extern datum gdbm_nextkey GDBM_Proto(( GDBM_FILE dbf, datum key )); extern int gdbm_reorganize GDBM_Proto(( GDBM_FILE dbf )); extern void gdbm_sync GDBM_Proto(( GDBM_FILE dbf )); extern int gdbm_exists GDBM_Proto(( GDBM_FILE dbf, datum key )); extern int gdbm_setopt GDBM_Proto(( GDBM_FILE dbf, int optflag, int *optval, int optlen )); #if defined(__cplusplus) || defined(c_plusplus) } #endif gdbm-1.7.2/gdbm.proto2100600 24413 24 377 5507307072 13235 0ustar downsjuser /* extra prototypes */ /* GDBM C++ support */ #if defined(__cplusplus) || defined(c_plusplus) extern "C" { #endif extern const char *gdbm_strerror GDBM_Proto(( gdbm_error error )); #if defined(__cplusplus) || defined(c_plusplus) } #endif #endif gdbm-1.7.2/conv2gdbm.c100600 24413 24 10266 5507303664 13243 0ustar downsjuser/* conv2gdbm.c - This is a program to convert dbm files to gdbm files. */ /* This file is part of GDBM, the GNU data base manager, by Philip A. Nelson. Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc. GDBM is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GDBM 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. You may contact the author by: e-mail: phil@cs.wwu.edu us-mail: Philip A. Nelson Computer Science Department Western Washington University Bellingham, WA 98226 *************************************************************************/ /* include system configuration before all else. */ #include "autoconf.h" #include #if HAVE_STDLIB_H #include #endif #include "gdbm.h" #include "getopt.h" extern int dbminit (); extern datum fetch (); extern datum firstkey (); extern datum nextkey (); static void usage(); /* Boolean Constants */ #define TRUE 1 #define FALSE 0 int main (argc, argv) int argc; char *argv[]; { GDBM_FILE gfile; /* The gdbm file. */ datum key; /* Key and data pairs retrieved. */ datum data; int errors; /* error count. */ int num; /* insert count. */ int block_size; /* gdbm block size. */ char quiet; /* Do work Quietly? */ char option_char; /* The option character. */ char *dbm_file, *gdbm_file; /* pointers to the file names. */ /* Initialize things. */ quiet = FALSE; block_size = 0; /* Check for proper arguments. */ if (argc < 2) usage (argv[0]); /* Check for the options. */ while ( (option_char = getopt (argc, argv, "b:q")) != EOF) { switch (option_char) { case 'b': block_size = atoi (optarg); break; case 'q': quiet = TRUE; break; default: usage (argv[0]); } } /* The required dbm file name. */ if (argc <= optind) { usage (argv[0]); } else { dbm_file = argv[optind]; gdbm_file = argv[optind]; optind += 1; } /* The optional gdbm file name. */ if (argc > optind) { gdbm_file = argv[optind]; optind += 1; } /* No more arguments are legal. */ if (argc > optind) usage (argv[0]); /* Open the dbm file. */ if (dbminit (dbm_file) != 0) { printf ("%s: dbm file not opened\n", argv[0]); exit (2); } /* Open the gdbm file. Since the dbm files have .pag and .dir we will use the file name without any extension. */ gfile = gdbm_open (gdbm_file, block_size, GDBM_WRCREAT, 00664, NULL); if (gfile == NULL) { printf ("%s: gdbm file not opened\n", argv[0]); exit (2); } /* Do the conversion. */ errors = 0; num = 0; if (!quiet) printf ("%s: Converting %s.pag and %s.dir to %s.\n", argv[0], dbm_file, dbm_file, gdbm_file); /* The convert loop - read a key/data pair from the dbm file and insert it into the gdbm file. */ for (key = firstkey (); key.dptr != NULL; key = nextkey (key)) { data = fetch (key); if (gdbm_store (gfile, key, data, GDBM_INSERT) != 0) { errors++; } else { num++; if ( !quiet && ((num % 100) == 0)) { printf ("."); if ( (num % 7000) == 0) printf ("\n"); } } } gdbm_close (gfile); if (!quiet) { /* Final reporting. */ if (errors) printf ("%s: %d items not inserted into %s.\n", argv[0], errors, gdbm_file); printf ("%s: %d items inserted into %s.\n", argv[0], num, gdbm_file); } exit(0); /* NOTREACHED */ } static void usage (name) char *name; { printf ("usage: %s [-q] [-b block_size] dbmfile [gdbmfile]\n", name); exit (2); } gdbm-1.7.2/configure100700 24413 24 71671 5565365531 13137 0ustar downsjuser#!/bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated automatically using autoconf. # Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # This program 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 General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # Usage: configure [--srcdir=DIR] [--host=HOST] [--gas] [--nfp] # [--prefix=PREFIX] [--exec-prefix=PREFIX] [--with-PACKAGE[=VALUE]] # Ignores all args except --srcdir, --prefix, --exec-prefix, and # --with-PACKAGE[=VALUE] unless this script has special code to handle it. for arg do # Handle --exec-prefix with a space before the argument. if test x$next_exec_prefix = xyes; then exec_prefix=$arg; next_exec_prefix= # Handle --host with a space before the argument. elif test x$next_host = xyes; then next_host= # Handle --prefix with a space before the argument. elif test x$next_prefix = xyes; then prefix=$arg; next_prefix= # Handle --srcdir with a space before the argument. elif test x$next_srcdir = xyes; then srcdir=$arg; next_srcdir= else case $arg in # For backward compatibility, recognize -exec-prefix and --exec_prefix. -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* | --exec=* | --exe=* | --ex=* | --e=*) exec_prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- | --exec | --exe | --ex | --e) next_exec_prefix=yes ;; -gas | --gas | --ga | --g) ;; -host=* | --host=* | --hos=* | --ho=* | --h=*) ;; -host | --host | --hos | --ho | --h) next_host=yes ;; -nfp | --nfp | --nf) ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) next_prefix=yes ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=* | --s=*) srcdir=`echo $arg | sed 's/[-a-z_]*=//'` ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr | --s) next_srcdir=yes ;; -with-* | --with-*) package=`echo $arg|sed -e 's/-*with-//' -e 's/=.*//'` # Reject names that aren't valid shell variable names. if test -n "`echo $package| sed 's/[-a-zA-Z0-9_]//g'`"; then echo "configure: $package: invalid package name" >&2; exit 1 fi package=`echo $package| sed 's/-/_/g'` case "$arg" in *=*) val="`echo $arg|sed 's/[^=]*=//'`" ;; *) val=1 ;; esac eval "with_$package='$val'" ;; -v | -verbose | --verbose | --verbos | --verbo | --verb | --ver | --ve | --v) verbose=yes ;; *) ;; esac fi done trap 'rm -fr conftest* confdefs* core; exit 1' 1 3 15 trap 'rm -f confdefs*' 0 # NLS nuisances. # These must not be set unconditionally because not all systems understand # e.g. LANG=C (notably SCO). if test "${LC_ALL+set}" = 'set' ; then LC_ALL=C; export LC_ALL; fi if test "${LANG+set}" = 'set' ; then LANG=C; export LANG; fi rm -f conftest* confdefs.h # AIX cpp loses on an empty file, so make sure it contains at least a newline. echo > confdefs.h compile='${CC-cc} $CFLAGS conftest.c -o conftest $LIBS >/dev/null 2>&1' # A filename unique to this package, relative to the directory that # configure is in, which we can look for to find out if srcdir is correct. unique_file=gdbmdefs.h # Find the source files, if location was not specified. if test -z "$srcdir"; then srcdirdefaulted=yes # Try the directory containing this script, then `..'. prog=$0 confdir=`echo $prog|sed 's%/[^/][^/]*$%%'` test "X$confdir" = "X$prog" && confdir=. srcdir=$confdir if test ! -r $srcdir/$unique_file; then srcdir=.. fi fi if test ! -r $srcdir/$unique_file; then if test x$srcdirdefaulted = xyes; then echo "configure: Can not find sources in \`${confdir}' or \`..'." 1>&2 else echo "configure: Can not find sources in \`${srcdir}'." 1>&2 fi exit 1 fi # Preserve a srcdir of `.' to avoid automounter screwups with pwd. # But we can't avoid them for `..', to make subdirectories work. case $srcdir in .|/*|~*) ;; *) srcdir=`cd $srcdir; pwd` ;; # Make relative path absolute. esac # Save the original args to write them into config.status later. configure_args="$*" if test -z "$CC"; then # Extract the first word of `gcc', so it can be a program name with args. set dummy gcc; word=$2 echo checking for $word IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:" for dir in $PATH; do test -z "$dir" && dir=. if test -f $dir/$word; then CC="gcc" break fi done IFS="$saveifs" fi test -z "$CC" && CC="cc" test -n "$CC" && test -n "$verbose" && echo " setting CC to $CC" # Find out if we are using GNU C, under whatever name. cat > conftest.c < conftest.out 2>&1 if egrep yes conftest.out >/dev/null 2>&1; then GCC=1 # For later tests. fi rm -f conftest* echo checking how to run the C preprocessor if test -z "$CPP"; then # This must be in double quotes, not single quotes, because CPP may get # substituted into the Makefile and ``${CC-cc}'' will simply confuse # make. It must be expanded now. CPP="${CC-cc} -E" cat > conftest.c < Syntax Error EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then : else rm -rf conftest* CPP=/lib/cpp fi rm -f conftest* fi test ".${verbose}" != "." && echo " setting CPP to $CPP" # Make sure to not get the incompatible SysV /etc/install and # /usr/sbin/install, which might be in PATH before a BSD-like install, # or the SunOS /usr/etc/install directory, or the AIX /bin/install, # or the AFS install, which mishandles nonexistent args, or # /usr/ucb/install on SVR4, which tries to use the nonexistent group # `staff'. On most BSDish systems install is in /usr/bin, not /usr/ucb # anyway. Sigh. if test "z${INSTALL}" = "z" ; then echo checking for install IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:" for dir in $PATH; do test -z "$dir" && dir=. case $dir in /etc|/usr/sbin|/usr/etc|/usr/afsws/bin|/usr/ucb) ;; *) if test -f $dir/installbsd; then INSTALL="$dir/installbsd -c" # OSF1 INSTALL_PROGRAM='$(INSTALL)' INSTALL_DATA='$(INSTALL) -m 644' break fi if test -f $dir/install; then if grep dspmsg $dir/install >/dev/null 2>&1; then : # AIX else INSTALL="$dir/install -c" INSTALL_PROGRAM='$(INSTALL)' INSTALL_DATA='$(INSTALL) -m 644' break fi fi ;; esac done IFS="$saveifs" fi INSTALL=${INSTALL-cp} test -n "$verbose" && echo " setting INSTALL to $INSTALL" INSTALL_PROGRAM=${INSTALL_PROGRAM-'$(INSTALL)'} test -n "$verbose" && echo " setting INSTALL_PROGRAM to $INSTALL_PROGRAM" INSTALL_DATA=${INSTALL_DATA-'$(INSTALL)'} test -n "$verbose" && echo " setting INSTALL_DATA to $INSTALL_DATA" if test -z "$RANLIB"; then # Extract the first word of `ranlib', so it can be a program name with args. set dummy ranlib; word=$2 echo checking for $word IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:" for dir in $PATH; do test -z "$dir" && dir=. if test -f $dir/$word; then RANLIB="ranlib" break fi done IFS="$saveifs" fi test -z "$RANLIB" && RANLIB=":" test -n "$RANLIB" && test -n "$verbose" && echo " setting RANLIB to $RANLIB" echo checking integer size cat > conftest.c </dev/null; then { test -n "$verbose" && \ echo " defining INT_16_BITS" echo "#define" INT_16_BITS 1 >> confdefs.h DEFS="$DEFS -DINT_16_BITS=1" SEDDEFS="${SEDDEFS}\${SEDdA}INT_16_BITS\${SEDdB}INT_16_BITS\${SEDdC}1\${SEDdD} \${SEDuA}INT_16_BITS\${SEDuB}INT_16_BITS\${SEDuC}1\${SEDuD} \${SEDeA}INT_16_BITS\${SEDeB}INT_16_BITS\${SEDeC}1\${SEDeD} " } fi rm -fr conftest* echo checking for 64-bit long ints cat > conftest.c </dev/null; then { test -n "$verbose" && \ echo " defining LONG_64_BITS" echo "#define" LONG_64_BITS 1 >> confdefs.h DEFS="$DEFS -DLONG_64_BITS=1" SEDDEFS="${SEDDEFS}\${SEDdA}LONG_64_BITS\${SEDdB}LONG_64_BITS\${SEDdC}1\${SEDdD} \${SEDuA}LONG_64_BITS\${SEDuB}LONG_64_BITS\${SEDuC}1\${SEDuD} \${SEDeA}LONG_64_BITS\${SEDeB}LONG_64_BITS\${SEDeC}1\${SEDeD} " } fi rm -fr conftest* echo checking byte ordering cat > conftest.c </dev/null; then : else { test -n "$verbose" && \ echo " defining WORDS_BIGENDIAN" echo "#define" WORDS_BIGENDIAN 1 >> confdefs.h DEFS="$DEFS -DWORDS_BIGENDIAN=1" SEDDEFS="${SEDDEFS}\${SEDdA}WORDS_BIGENDIAN\${SEDdB}WORDS_BIGENDIAN\${SEDdC}1\${SEDdD} \${SEDuA}WORDS_BIGENDIAN\${SEDuB}WORDS_BIGENDIAN\${SEDuC}1\${SEDuD} \${SEDeA}WORDS_BIGENDIAN\${SEDeB}WORDS_BIGENDIAN\${SEDeC}1\${SEDeD} " } fi rm -fr conftest* prog='/* Ultrix mips cc rejects this. */ typedef int charset[2]; const charset x; /* SunOS 4.1.1 cc rejects this. */ char const *const *ccp; char **p; /* AIX XL C 1.02.0.0 rejects this. It does not let you subtract one const X* pointer from another in an arm of an if-expression whose if-part is not a constant expression */ const char *g = "string"; ccp = &g + (g ? g-g : 0); /* HPUX 7.0 cc rejects these. */ ++ccp; p = (char**) ccp; ccp = (char const *const *) p; { /* SCO 3.2v4 cc rejects this. */ char *t; char const *s = 0 ? (char *) 0 : (char const *) 0; *t++ = 0; } { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ int x[] = {25,17}; const int *foo = &x[0]; ++foo; } { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ typedef const int *iptr; iptr p = 0; ++p; } { /* AIX XL C 1.02.0.0 rejects this saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ struct s { int j; const int *ap[3]; }; struct s *b; b->j = 5; } { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ const int foo = 10; }' echo checking for lack of working const cat > conftest.c <> confdefs.h DEFS="$DEFS -Dconst=" SEDDEFS="${SEDDEFS}\${SEDdA}const\${SEDdB}const\${SEDdC}\${SEDdD} \${SEDuA}const\${SEDuB}const\${SEDuC}\${SEDuD} \${SEDeA}const\${SEDeB}const\${SEDeC}\${SEDeD} " } fi rm -f conftest* for hdr in stdlib.h string.h sys/file.h unistd.h fcntl.h sys/types.h do trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'` echo checking for ${hdr} cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${trhdr}" echo "#define" ${trhdr} 1 >> confdefs.h DEFS="$DEFS -D${trhdr}=1" SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD} \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD} \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD} " } fi rm -f conftest* done for hdr in memory.h do trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'` echo checking for ${hdr} cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${trhdr}" echo "#define" ${trhdr} 1 >> confdefs.h DEFS="$DEFS -D${trhdr}=1" SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD} \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD} \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD} " } fi rm -f conftest* done LIBS_save="${LIBS}" LIBS="${LIBS} -ldbm" have_lib="" echo checking for -ldbm cat > conftest.c <> confdefs.h DEFS="$DEFS -DHAVE_LIBDBM=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_LIBDBM\${SEDdB}HAVE_LIBDBM\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_LIBDBM\${SEDuB}HAVE_LIBDBM\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_LIBDBM\${SEDeB}HAVE_LIBDBM\${SEDeC}1\${SEDeD} " } LIBS="${LIBS} -ldbm" fi LIBS_save="${LIBS}" LIBS="${LIBS} -lndbm" have_lib="" echo checking for -lndbm cat > conftest.c <> confdefs.h DEFS="$DEFS -DHAVE_LIBNDBM=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_LIBNDBM\${SEDdB}HAVE_LIBNDBM\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_LIBNDBM\${SEDuB}HAVE_LIBNDBM\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_LIBNDBM\${SEDeB}HAVE_LIBNDBM\${SEDeC}1\${SEDeD} " } LIBS="${LIBS} -lndbm" fi for func in rename ftruncate flock bcopy fsync do trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'` echo checking for ${func} cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${func}) || defined (__stub___${func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${func}(); ${func}(); #endif } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${trfunc}" echo "#define" ${trfunc} 1 >> confdefs.h DEFS="$DEFS -D${trfunc}=1" SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD} \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD} \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD} " } fi rm -f conftest* done for func in getopt do echo checking for ${func} cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${func}) || defined (__stub___${func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${func}(); ${func}(); #endif } EOF if eval $compile; then : else rm -rf conftest* LIBOBJS="$LIBOBJS ${func}.o" test -n "$verbose" && echo " using ${func}.o instead" fi rm -f conftest* done # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works # for constant arguments. Useless! echo checking for working alloca.h cat > conftest.c < int main() { exit(0); } int t() { char *p = alloca(2 * sizeof(int)); } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_ALLOCA_H" echo "#define" HAVE_ALLOCA_H 1 >> confdefs.h DEFS="$DEFS -DHAVE_ALLOCA_H=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_ALLOCA_H\${SEDdB}HAVE_ALLOCA_H\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_ALLOCA_H\${SEDuB}HAVE_ALLOCA_H\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_ALLOCA_H\${SEDeB}HAVE_ALLOCA_H\${SEDeC}1\${SEDeD} " } fi rm -f conftest* decl="#ifdef __GNUC__ #define alloca __builtin_alloca #else #if HAVE_ALLOCA_H #include #else #ifdef _AIX #pragma alloca #else char *alloca (); #endif #endif #endif " echo checking for alloca cat > conftest.c < conftest.c < conftest.out 2>&1" if egrep "winnitude" conftest.out >/dev/null 2>&1; then rm -rf conftest* echo checking for _getb67 cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub__getb67) || defined (__stub____getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char _getb67(); _getb67(); #endif } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be _getb67 echo "#define" CRAY_STACKSEG_END _getb67 >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=_getb67" SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}_getb67\${SEDdD} \${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}_getb67\${SEDuD} \${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}_getb67\${SEDeD} " } else rm -rf conftest* echo checking for GETB67 cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_GETB67) || defined (__stub___GETB67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char GETB67(); GETB67(); #endif } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be GETB67 echo "#define" CRAY_STACKSEG_END GETB67 >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=GETB67" SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}GETB67\${SEDdD} \${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}GETB67\${SEDuD} \${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}GETB67\${SEDeD} " } else rm -rf conftest* echo checking for getb67 cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_getb67) || defined (__stub___getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char getb67(); getb67(); #endif } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be getb67 echo "#define" CRAY_STACKSEG_END getb67 >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=getb67" SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}getb67\${SEDdD} \${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}getb67\${SEDuD} \${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}getb67\${SEDeD} " } fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* if test -n "$alloca_missing"; then # The SVR3 libPW and SVR4 libucb both contain incompatible functions # that cause trouble. Some versions do not even contain alloca or # contain a buggy version. If you still want to use their alloca, # use ar to extract alloca.o from them instead of compiling alloca.c. ALLOCA=alloca.o { test -n "$verbose" && \ echo " defining C_ALLOCA" echo "#define" C_ALLOCA 1 >> confdefs.h DEFS="$DEFS -DC_ALLOCA=1" SEDDEFS="${SEDDEFS}\${SEDdA}C_ALLOCA\${SEDdB}C_ALLOCA\${SEDdC}1\${SEDdD} \${SEDuA}C_ALLOCA\${SEDuB}C_ALLOCA\${SEDuC}1\${SEDuD} \${SEDeA}C_ALLOCA\${SEDeB}C_ALLOCA\${SEDeC}1\${SEDeD} " } echo 'checking stack direction for C alloca' echo checking whether cross-compiling # If we cannot run a trivial program, we must be cross compiling. cat > conftest.c </dev/null; then : else cross_compiling=1 fi rm -fr conftest* if test -n "$cross_compiling" then { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be 0 echo "#define" STACK_DIRECTION 0 >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=0" SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}0\${SEDdD} \${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}0\${SEDuD} \${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}0\${SEDeD} " } else cat > conftest.c < addr) ? 1 : -1; } main () { exit (find_stack_direction() < 0); } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be 1 echo "#define" STACK_DIRECTION 1 >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=1" SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}1\${SEDdD} \${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}1\${SEDuD} \${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}1\${SEDeD} " } else { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be -1 echo "#define" STACK_DIRECTION -1 >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=-1" SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}-1\${SEDdD} \${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}-1\${SEDuD} \${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}-1\${SEDeD} " } fi fi rm -fr conftest* fi echo checking for off_t in sys/types.h echo '#include "confdefs.h" #include ' > conftest.c eval "$CPP conftest.c > conftest.out 2>&1" if egrep "off_t" conftest.out >/dev/null 2>&1; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining" off_t to be long echo "#define" off_t long >> confdefs.h DEFS="$DEFS -Doff_t=long" SEDDEFS="${SEDDEFS}\${SEDdA}off_t\${SEDdB}off_t\${SEDdC}long\${SEDdD} \${SEDuA}off_t\${SEDuB}off_t\${SEDuC}long\${SEDuD} \${SEDeA}off_t\${SEDeB}off_t\${SEDeC}long\${SEDeD} " } fi rm -f conftest* echo checking for st_blksize in struct stat cat > conftest.c < #include int main() { exit(0); } int t() { struct stat s; s.st_blksize; } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_ST_BLKSIZE" echo "#define" HAVE_ST_BLKSIZE 1 >> confdefs.h DEFS="$DEFS -DHAVE_ST_BLKSIZE=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_ST_BLKSIZE\${SEDdB}HAVE_ST_BLKSIZE\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_ST_BLKSIZE\${SEDuB}HAVE_ST_BLKSIZE\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_ST_BLKSIZE\${SEDeB}HAVE_ST_BLKSIZE\${SEDeC}1\${SEDeD} " } fi rm -f conftest* # Set default prefixes. if test -n "$prefix"; then test -z "$exec_prefix" && exec_prefix='${prefix}' prsub="s%^prefix\\([ ]*\\)=\\([ ]*\\).*$%prefix\\1=\\2$prefix%" fi if test -n "$exec_prefix"; then prsub="$prsub s%^exec_prefix\\([ ]*\\)=\\([ ]*\\).*$%exec_prefix\\1=\\2$exec_prefix%" fi # Quote sed substitution magic chars in DEFS. cat >conftest.def < config.status </dev/null | sed 1q`: # # $0 $configure_args for arg do case "\$arg" in -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) echo running \${CONFIG_SHELL-/bin/sh} $0 $configure_args exec \${CONFIG_SHELL-/bin/sh} $0 $configure_args ;; *) echo "Usage: config.status --recheck" 2>&1; exit 1 ;; esac done trap 'rm -fr Makefile autoconf.h conftest*; exit 1' 1 3 15 CC='$CC' CPP='$CPP' INSTALL='$INSTALL' INSTALL_PROGRAM='$INSTALL_PROGRAM' INSTALL_DATA='$INSTALL_DATA' RANLIB='$RANLIB' LIBOBJS='$LIBOBJS' ALLOCA='$ALLOCA' LIBS='$LIBS' srcdir='$srcdir' prefix='$prefix' exec_prefix='$exec_prefix' prsub='$prsub' extrasub='$extrasub' EOF cat >> config.status <<\EOF top_srcdir=$srcdir CONFIG_FILES=${CONFIG_FILES-"Makefile"} for file in .. ${CONFIG_FILES}; do if test "x$file" != x..; then srcdir=$top_srcdir # Remove last slash and all that follows it. Not all systems have dirname. dir=`echo $file|sed 's%/[^/][^/]*$%%'` if test "$dir" != "$file"; then test "$top_srcdir" != . && srcdir=$top_srcdir/$dir test ! -d $dir && mkdir $dir fi echo creating $file rm -f $file echo "# Generated automatically from `echo $file|sed 's|.*/||'`.in by configure." > $file sed -e " $prsub $extrasub s%@CC@%$CC%g s%@CPP@%$CPP%g s%@INSTALL@%$INSTALL%g s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g s%@INSTALL_DATA@%$INSTALL_DATA%g s%@RANLIB@%$RANLIB%g s%@LIBOBJS@%$LIBOBJS%g s%@ALLOCA@%$ALLOCA%g s%@LIBS@%$LIBS%g s%@srcdir@%$srcdir%g s%@DEFS@%-DHAVE_CONFIG_H%" $top_srcdir/${file}.in >> $file fi; done CONFIG_HEADERS=${CONFIG_HEADERS-"autoconf.h"} for file in .. ${CONFIG_HEADERS}; do if test "x$file" != x..; then echo creating $file # These sed commands are put into SEDDEFS when defining a macro. # They are broken into pieces to make the sed script easier to manage. # They are passed to sed as "A NAME B NAME C VALUE D", where NAME # is the cpp macro being defined and VALUE is the value it is being given. # Each defining turns into a single global substitution command. # # SEDd sets the value in "#define NAME VALUE" lines. SEDdA='s@^\([ ]*\)#\([ ]*define[ ][ ]*\)' SEDdB='\([ ][ ]*\)[^ ]*@\1#\2' SEDdC='\3' SEDdD='@g' # SEDu turns "#undef NAME" with trailing blanks into "#define NAME VALUE". SEDuA='s@^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' SEDuB='\([ ]\)@\1#\2define\3' SEDuC=' ' SEDuD='\4@g' # SEDe turns "#undef NAME" without trailing blanks into "#define NAME VALUE". SEDeA='s@^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' SEDeB='$@\1#\2define\3' SEDeC=' ' SEDeD='@g' rm -f conftest.sed EOF # Turn off quoting long enough to insert the sed commands. rm -f conftest.sh cat > conftest.sh < conftest.s1 # Like head -20. sed 1,${maxshlines}d conftest.sh > conftest.s2 # Like tail +21. # Write a limited-size here document to append to conftest.sed. echo 'cat >> conftest.sed <> config.status cat conftest.s1 >> config.status echo 'CONFEOF' >> config.status rm -f conftest.s1 conftest.sh mv conftest.s2 conftest.sh done rm -f conftest.sh # Now back to your regularly scheduled config.status. cat >> config.status <<\EOF # This sed command replaces #undef's with comments. This is necessary, for # example, in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it in # autoconf.h. cat >> conftest.sed <<\CONFEOF s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */, CONFEOF rm -f conftest.h # Break up the sed commands because old seds have small limits. maxsedlines=20 cp $top_srcdir/$file.in conftest.h1 while : do lines=`grep -c . conftest.sed` if test -z "$lines" || test "$lines" -eq 0; then break; fi rm -f conftest.s1 conftest.s2 conftest.h2 sed ${maxsedlines}q conftest.sed > conftest.s1 # Like head -20. sed 1,${maxsedlines}d conftest.sed > conftest.s2 # Like tail +21. sed -f conftest.s1 < conftest.h1 > conftest.h2 rm -f conftest.s1 conftest.h1 conftest.sed mv conftest.h2 conftest.h1 mv conftest.s2 conftest.sed done rm -f conftest.sed conftest.h echo "/* $file. Generated automatically by configure. */" > conftest.h cat conftest.h1 >> conftest.h rm -f conftest.h1 if cmp -s $file conftest.h 2>/dev/null; then # The file exists and we would not be changing it. echo "$file is unchanged" rm -f conftest.h else rm -f $file mv conftest.h $file fi fi; done exit 0 EOF chmod +x config.status ${CONFIG_SHELL-/bin/sh} config.status gdbm-1.7.2/configure.in100600 24413 24 1004 5565365364 13506 0ustar downsjuserdnl Process this file with autoconf to produce a configure script. dnl Initialize AC_INIT(gdbmdefs.h) AC_CONFIG_HEADER(autoconf.h) AC_PROG_CC AC_PROG_CPP AC_PROG_INSTALL AC_PROG_RANLIB AC_INT_16_BITS AC_LONG_64_BITS AC_WORDS_BIGENDIAN AC_CONST AC_HAVE_HEADERS(stdlib.h string.h sys/file.h unistd.h fcntl.h sys/types.h) AC_HAVE_HEADERS(memory.h) AC_HAVE_LIBRARY(dbm) AC_HAVE_LIBRARY(ndbm) AC_HAVE_FUNCS(rename ftruncate flock bcopy fsync) AC_REPLACE_FUNCS(getopt) AC_ALLOCA AC_OFF_T AC_ST_BLKSIZE AC_OUTPUT(Makefile) gdbm-1.7.2/alloca.c100600 24413 24 31726 5471122420 12606 0ustar downsjuser/* alloca.c -- allocate automatically reclaimed memory (Mostly) portable public-domain implementation -- D A Gwyn This implementation of the PWB library alloca function, which is used to allocate space off the run-time stack so that it is automatically reclaimed upon procedure exit, was inspired by discussions with J. Q. Johnson of Cornell. J.Otto Tennant contributed the Cray support. There are some preprocessor constants that can be defined when compiling for your specific system, for improved efficiency; however, the defaults should be okay. The general concept of this implementation is to keep track of all alloca-allocated blocks, and reclaim any that are found to be deeper in the stack than the current invocation. This heuristic does not reclaim storage as soon as it becomes invalid, but it will do so eventually. As a special case, alloca(0) reclaims storage without allocating any. It is a good idea to use alloca(0) in your main control loop, etc. to force garbage collection. */ /* include system configuration before all else. */ #include "autoconf.h" #if HAVE_STDLIB_H #include #endif /* If compiling with GCC, this file's not needed. */ #ifndef alloca #ifdef emacs #ifdef static /* actually, only want this if static is defined as "" -- this is for usg, in which emacs must undefine static in order to make unexec workable */ #ifndef STACK_DIRECTION you lose -- must know STACK_DIRECTION at compile-time #endif /* STACK_DIRECTION undefined */ #endif /* static */ #endif /* emacs */ /* If your stack is a linked list of frames, you have to provide an "address metric" ADDRESS_FUNCTION macro. */ #ifdef CRAY long i00afunc (); #define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg)) #else #define ADDRESS_FUNCTION(arg) &(arg) #endif #if __STDC__ typedef void *pointer; #else typedef char *pointer; #endif #define NULL 0 /* Define STACK_DIRECTION if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #ifndef STACK_DIRECTION #define STACK_DIRECTION 0 /* Direction unknown. */ #endif #if STACK_DIRECTION != 0 #define STACK_DIR STACK_DIRECTION /* Known at compile-time. */ #else /* STACK_DIRECTION == 0; need run-time code. */ static int stack_dir; /* 1 or -1 once known. */ #define STACK_DIR stack_dir static void find_stack_direction () { static char *addr = NULL; /* Address of first `dummy', once known. */ auto char dummy; /* To get stack address. */ if (addr == NULL) { /* Initial entry. */ addr = ADDRESS_FUNCTION (dummy); find_stack_direction (); /* Recurse once. */ } else { /* Second entry. */ if (ADDRESS_FUNCTION (dummy) > addr) stack_dir = 1; /* Stack grew upward. */ else stack_dir = -1; /* Stack grew downward. */ } } #endif /* STACK_DIRECTION == 0 */ /* An "alloca header" is used to: (a) chain together all alloca'ed blocks; (b) keep track of stack depth. It is very important that sizeof(header) agree with malloc alignment chunk size. The following default should work okay. */ #ifndef ALIGN_SIZE #define ALIGN_SIZE sizeof(double) #endif typedef union hdr { char align[ALIGN_SIZE]; /* To force sizeof(header). */ struct { union hdr *next; /* For chaining headers. */ char *deep; /* For stack depth measure. */ } h; } header; static header *last_alloca_header = NULL; /* -> last alloca header. */ /* Return a pointer to at least SIZE bytes of storage, which will be automatically reclaimed upon exit from the procedure that called alloca. Originally, this space was supposed to be taken from the current stack frame of the caller, but that method cannot be made to work for some implementations of C, for example under Gould's UTX/32. */ pointer alloca (size) unsigned size; { auto char probe; /* Probes stack depth: */ register char *depth = ADDRESS_FUNCTION (probe); #if STACK_DIRECTION == 0 if (STACK_DIR == 0) /* Unknown growth direction. */ find_stack_direction (); #endif /* Reclaim garbage, defined as all alloca'd storage that was allocated from deeper in the stack than currently. */ { register header *hp; /* Traverses linked list. */ for (hp = last_alloca_header; hp != NULL;) if ((STACK_DIR > 0 && hp->h.deep > depth) || (STACK_DIR < 0 && hp->h.deep < depth)) { register header *np = hp->h.next; free ((pointer) hp); /* Collect garbage. */ hp = np; /* -> next header. */ } else break; /* Rest are not deeper. */ last_alloca_header = hp; /* -> last valid storage. */ } if (size == 0) return NULL; /* No allocation required. */ /* Allocate combined header + user data storage. */ { register pointer new = malloc (sizeof (header) + size); /* Address of header. */ ((header *) new)->h.next = last_alloca_header; ((header *) new)->h.deep = depth; last_alloca_header = (header *) new; /* User storage begins just after header. */ return (pointer) ((char *) new + sizeof (header)); } } #ifdef CRAY #ifdef DEBUG_I00AFUNC #include #endif #ifndef CRAY_STACK #define CRAY_STACK #ifndef CRAY2 /* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */ struct stack_control_header { long shgrow:32; /* Number of times stack has grown. */ long shaseg:32; /* Size of increments to stack. */ long shhwm:32; /* High water mark of stack. */ long shsize:32; /* Current size of stack (all segments). */ }; /* The stack segment linkage control information occurs at the high-address end of a stack segment. (The stack grows from low addresses to high addresses.) The initial part of the stack segment linkage control information is 0200 (octal) words. This provides for register storage for the routine which overflows the stack. */ struct stack_segment_linkage { long ss[0200]; /* 0200 overflow words. */ long sssize:32; /* Number of words in this segment. */ long ssbase:32; /* Offset to stack base. */ long:32; long sspseg:32; /* Offset to linkage control of previous segment of stack. */ long:32; long sstcpt:32; /* Pointer to task common address block. */ long sscsnm; /* Private control structure number for microtasking. */ long ssusr1; /* Reserved for user. */ long ssusr2; /* Reserved for user. */ long sstpid; /* Process ID for pid based multi-tasking. */ long ssgvup; /* Pointer to multitasking thread giveup. */ long sscray[7]; /* Reserved for Cray Research. */ long ssa0; long ssa1; long ssa2; long ssa3; long ssa4; long ssa5; long ssa6; long ssa7; long sss0; long sss1; long sss2; long sss3; long sss4; long sss5; long sss6; long sss7; }; #else /* CRAY2 */ /* The following structure defines the vector of words returned by the STKSTAT library routine. */ struct stk_stat { long now; /* Current total stack size. */ long maxc; /* Amount of contiguous space which would be required to satisfy the maximum stack demand to date. */ long high_water; /* Stack high-water mark. */ long overflows; /* Number of stack overflow ($STKOFEN) calls. */ long hits; /* Number of internal buffer hits. */ long extends; /* Number of block extensions. */ long stko_mallocs; /* Block allocations by $STKOFEN. */ long underflows; /* Number of stack underflow calls ($STKRETN). */ long stko_free; /* Number of deallocations by $STKRETN. */ long stkm_free; /* Number of deallocations by $STKMRET. */ long segments; /* Current number of stack segments. */ long maxs; /* Maximum number of stack segments so far. */ long pad_size; /* Stack pad size. */ long current_address; /* Current stack segment address. */ long current_size; /* Current stack segment size. This number is actually corrupted by STKSTAT to include the fifteen word trailer area. */ long initial_address; /* Address of initial segment. */ long initial_size; /* Size of initial segment. */ }; /* The following structure describes the data structure which trails any stack segment. I think that the description in 'asdef' is out of date. I only describe the parts that I am sure about. */ struct stk_trailer { long this_address; /* Address of this block. */ long this_size; /* Size of this block (does not include this trailer). */ long unknown2; long unknown3; long link; /* Address of trailer block of previous segment. */ long unknown5; long unknown6; long unknown7; long unknown8; long unknown9; long unknown10; long unknown11; long unknown12; long unknown13; long unknown14; }; #endif /* CRAY2 */ #endif /* not CRAY_STACK */ #ifdef CRAY2 /* Determine a "stack measure" for an arbitrary ADDRESS. I doubt that "lint" will like this much. */ static long i00afunc (long *address) { struct stk_stat status; struct stk_trailer *trailer; long *block, size; long result = 0; /* We want to iterate through all of the segments. The first step is to get the stack status structure. We could do this more quickly and more directly, perhaps, by referencing the $LM00 common block, but I know that this works. */ STKSTAT (&status); /* Set up the iteration. */ trailer = (struct stk_trailer *) (status.current_address + status.current_size - 15); /* There must be at least one stack segment. Therefore it is a fatal error if "trailer" is null. */ if (trailer == 0) abort (); /* Discard segments that do not contain our argument address. */ while (trailer != 0) { block = (long *) trailer->this_address; size = trailer->this_size; if (block == 0 || size == 0) abort (); trailer = (struct stk_trailer *) trailer->link; if ((block <= address) && (address < (block + size))) break; } /* Set the result to the offset in this segment and add the sizes of all predecessor segments. */ result = address - block; if (trailer == 0) { return result; } do { if (trailer->this_size <= 0) abort (); result += trailer->this_size; trailer = (struct stk_trailer *) trailer->link; } while (trailer != 0); /* We are done. Note that if you present a bogus address (one not in any segment), you will get a different number back, formed from subtracting the address of the first block. This is probably not what you want. */ return (result); } #else /* not CRAY2 */ /* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP. Determine the number of the cell within the stack, given the address of the cell. The purpose of this routine is to linearize, in some sense, stack addresses for alloca. */ static long i00afunc (long address) { long stkl = 0; long size, pseg, this_segment, stack; long result = 0; struct stack_segment_linkage *ssptr; /* Register B67 contains the address of the end of the current stack segment. If you (as a subprogram) store your registers on the stack and find that you are past the contents of B67, you have overflowed the segment. B67 also points to the stack segment linkage control area, which is what we are really interested in. */ stkl = CRAY_STACKSEG_END (); ssptr = (struct stack_segment_linkage *) stkl; /* If one subtracts 'size' from the end of the segment, one has the address of the first word of the segment. If this is not the first segment, 'pseg' will be nonzero. */ pseg = ssptr->sspseg; size = ssptr->sssize; this_segment = stkl - size; /* It is possible that calling this routine itself caused a stack overflow. Discard stack segments which do not contain the target address. */ while (!(this_segment <= address && address <= stkl)) { #ifdef DEBUG_I00AFUNC fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl); #endif if (pseg == 0) break; stkl = stkl - pseg; ssptr = (struct stack_segment_linkage *) stkl; size = ssptr->sssize; pseg = ssptr->sspseg; this_segment = stkl - size; } result = address - this_segment; /* If you subtract pseg from the current end of the stack, you get the address of the previous stack segment's end. This seems a little convoluted to me, but I'll bet you save a cycle somewhere. */ while (pseg != 0) { #ifdef DEBUG_I00AFUNC fprintf (stderr, "%011o %011o\n", pseg, size); #endif stkl = stkl - pseg; ssptr = (struct stack_segment_linkage *) stkl; size = ssptr->sssize; pseg = ssptr->sspseg; result += size; } return (result); } #endif /* not CRAY2 */ #endif /* CRAY */ #endif /* no alloca */ gdbm-1.7.2/getopt.c100600 24413 24 50562 5471123536 12665 0ustar downsjuser/* Getopt for GNU. NOTE: getopt is now part of the C library, so if you don't know what "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu before changing it! Copyright (C) 1987, 88, 89, 90, 91, 92, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* NOTE!!! AIX requires this to be the first thing in the file. Do not put ANYTHING before it! */ #if !defined (__GNUC__) && defined (_AIX) #pragma alloca #endif #include "autoconf.h" #ifdef __GNUC__ #define alloca __builtin_alloca #else /* not __GNUC__ */ #if defined (HAVE_ALLOCA_H) || (defined(sparc) && (defined(sun) || (!defined(USG) && !defined(SVR4) && !defined(__svr4__)))) #include #else #ifndef _AIX char *alloca (); #endif #endif /* alloca.h */ #endif /* not __GNUC__ */ #if !__STDC__ && !defined(const) && IN_GCC #define const #endif /* This tells Alpha OSF/1 not to define a getopt prototype in . */ #ifndef _NO_PROTO #define _NO_PROTO #endif #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #if defined (_LIBC) || !defined (__GNU_LIBRARY__) /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ #undef alloca /* Don't include stdlib.h for non-GNU C libraries because some of them contain conflicting prototypes for getopt. */ #include #else /* Not GNU C library. */ #define __alloca alloca #endif /* GNU C library. */ /* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a long-named option. Because this is not POSIX.2 compliant, it is being phased out. */ /* #define GETOPT_COMPAT */ /* This version of `getopt' appears to the caller like standard Unix `getopt' but it behaves differently for the user, since it allows the user to intersperse the options with the other arguments. As `getopt' works, it permutes the elements of ARGV so that, when it is done, all the options precede everything else. Thus all application programs are extended to handle flexible argument order. Setting the environment variable POSIXLY_CORRECT disables permutation. Then the behavior is completely standard. GNU application programs can use a third alternative mode in which they can distinguish the relative order of options and other arguments. */ #include "getopt.h" /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ char *optarg = 0; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns EOF, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ /* XXX 1003.2 says this must be 1 before any call. */ int optind = 0; /* The next char to be scanned in the option-element in which the last option character we returned was found. This allows us to pick up the scan where we left off. If this is zero, or a null string, it means resume the scan by advancing to the next ARGV-element. */ static char *nextchar; /* Callers store zero here to inhibit the error message for unrecognized options. */ int opterr = 1; /* Set to an option character which was unrecognized. This must be initialized on some systems to avoid linking in the system's own getopt implementation. */ int optopt = '?'; /* Describe how to deal with options that follow non-option ARGV-elements. If the caller did not specify anything, the default is REQUIRE_ORDER if the environment variable POSIXLY_CORRECT is defined, PERMUTE otherwise. REQUIRE_ORDER means don't recognize them as options; stop option processing when the first non-option is seen. This is what Unix does. This mode of operation is selected by either setting the environment variable POSIXLY_CORRECT, or using `+' as the first character of the list of option characters. PERMUTE is the default. We permute the contents of ARGV as we scan, so that eventually all the non-options are at the end. This allows options to be given in any order, even with programs that were not written to expect this. RETURN_IN_ORDER is an option available to programs that were written to expect options and other ARGV-elements in any order and that care about the ordering of the two. We describe each non-option ARGV-element as if it were the argument of an option with character code 1. Using `-' as the first character of the list of option characters selects this mode of operation. The special argument `--' forces an end of option-scanning regardless of the value of `ordering'. In the case of RETURN_IN_ORDER, only `--' can cause `getopt' to return EOF with `optind' != ARGC. */ static enum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering; #ifdef __GNU_LIBRARY__ /* We want to avoid inclusion of string.h with non-GNU libraries because there are many ways it can cause trouble. On some systems, it contains special magic macros that don't work in GCC. */ #include #define my_index strchr #define my_bcopy(src, dst, n) memcpy ((dst), (src), (n)) #else /* Avoid depending on library functions or files whose names are inconsistent. */ char *getenv (); static char * my_index (str, chr) const char *str; int chr; { while (*str) { if (*str == chr) return (char *) str; str++; } return 0; } static void my_bcopy (from, to, size) const char *from; char *to; int size; { int i; for (i = 0; i < size; i++) to[i] = from[i]; } #endif /* GNU C library. */ /* Handle permutation of arguments. */ /* Describe the part of ARGV that contains non-options that have been skipped. `first_nonopt' is the index in ARGV of the first of them; `last_nonopt' is the index after the last of them. */ static int first_nonopt; static int last_nonopt; /* Exchange two adjacent subsequences of ARGV. One subsequence is elements [first_nonopt,last_nonopt) which contains all the non-options that have been skipped so far. The other is elements [last_nonopt,optind), which contains all the options processed since those non-options were skipped. `first_nonopt' and `last_nonopt' are relocated so that they describe the new indices of the non-options in ARGV after they are moved. */ static void exchange (argv) char **argv; { int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *); char **temp = (char **) __alloca (nonopts_size); /* Interchange the two blocks of data in ARGV. */ my_bcopy ((char *) &argv[first_nonopt], (char *) temp, nonopts_size); my_bcopy ((char *) &argv[last_nonopt], (char *) &argv[first_nonopt], (optind - last_nonopt) * sizeof (char *)); my_bcopy ((char *) temp, (char *) &argv[first_nonopt + optind - last_nonopt], nonopts_size); /* Update records for the slots the non-options now occupy. */ first_nonopt += (optind - last_nonopt); last_nonopt = optind; } /* Scan elements of ARGV (whose length is ARGC) for option characters given in OPTSTRING. If an element of ARGV starts with '-', and is not exactly "-" or "--", then it is an option element. The characters of this element (aside from the initial '-') are option characters. If `getopt' is called repeatedly, it returns successively each of the option characters from each of the option elements. If `getopt' finds another option character, it returns that character, updating `optind' and `nextchar' so that the next call to `getopt' can resume the scan with the following option character or ARGV-element. If there are no more option characters, `getopt' returns `EOF'. Then `optind' is the index in ARGV of the first ARGV-element that is not an option. (The ARGV-elements have been permuted so that those that are not options now come last.) OPTSTRING is a string containing the legitimate option characters. If an option character is seen that is not listed in OPTSTRING, return '?' after printing an error message. If you set `opterr' to zero, the error message is suppressed but we still return '?'. If a char in OPTSTRING is followed by a colon, that means it wants an arg, so the following text in the same ARGV-element, or the text of the following ARGV-element, is returned in `optarg'. Two colons mean an option that wants an optional arg; if there is text in the current ARGV-element, it is returned in `optarg', otherwise `optarg' is set to zero. If OPTSTRING starts with `-' or `+', it requests different methods of handling the non-option ARGV-elements. See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. Long-named options begin with `--' instead of `-'. Their names may be abbreviated as long as the abbreviation is unique or is an exact match for some defined option. If they have an argument, it follows the option name in the same ARGV-element, separated from the option name by a `=', or else the in next ARGV-element. When `getopt' finds a long-named option, it returns 0 if that option's `flag' field is nonzero, the value of the option's `val' field if the `flag' field is zero. The elements of ARGV aren't really const, because we permute them. But we pretend they're const in the prototype to be compatible with other systems. LONGOPTS is a vector of `struct option' terminated by an element containing a name which is zero. LONGIND returns the index in LONGOPT of the long-named option found. It is only valid when a long-named option has been found by the most recent call. If LONG_ONLY is nonzero, '-' as well as '--' can introduce long-named options. */ int _getopt_internal (argc, argv, optstring, longopts, longind, long_only) int argc; char *const *argv; const char *optstring; const struct option *longopts; int *longind; int long_only; { int option_index; optarg = 0; /* Initialize the internal data when the first call is made. Start processing options with ARGV-element 1 (since ARGV-element 0 is the program name); the sequence of previously skipped non-option ARGV-elements is empty. */ if (optind == 0) { first_nonopt = last_nonopt = optind = 1; nextchar = NULL; /* Determine how to handle the ordering of options and nonoptions. */ if (optstring[0] == '-') { ordering = RETURN_IN_ORDER; ++optstring; } else if (optstring[0] == '+') { ordering = REQUIRE_ORDER; ++optstring; } else if (getenv ("POSIXLY_CORRECT") != NULL) ordering = REQUIRE_ORDER; else ordering = PERMUTE; } if (nextchar == NULL || *nextchar == '\0') { if (ordering == PERMUTE) { /* If we have just processed some options following some non-options, exchange them so that the options come first. */ if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (last_nonopt != optind) first_nonopt = optind; /* Now skip any additional non-options and extend the range of non-options previously skipped. */ while (optind < argc && (argv[optind][0] != '-' || argv[optind][1] == '\0') #ifdef GETOPT_COMPAT && (longopts == NULL || argv[optind][0] != '+' || argv[optind][1] == '\0') #endif /* GETOPT_COMPAT */ ) optind++; last_nonopt = optind; } /* Special ARGV-element `--' means premature end of options. Skip it like a null option, then exchange with previous non-options as if it were an option, then skip everything else like a non-option. */ if (optind != argc && !strcmp (argv[optind], "--")) { optind++; if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (first_nonopt == last_nonopt) first_nonopt = optind; last_nonopt = argc; optind = argc; } /* If we have done all the ARGV-elements, stop the scan and back over any non-options that we skipped and permuted. */ if (optind == argc) { /* Set the next-arg-index to point at the non-options that we previously skipped, so the caller will digest them. */ if (first_nonopt != last_nonopt) optind = first_nonopt; return EOF; } /* If we have come to a non-option and did not permute it, either stop the scan or describe it to the caller and pass it by. */ if ((argv[optind][0] != '-' || argv[optind][1] == '\0') #ifdef GETOPT_COMPAT && (longopts == NULL || argv[optind][0] != '+' || argv[optind][1] == '\0') #endif /* GETOPT_COMPAT */ ) { if (ordering == REQUIRE_ORDER) return EOF; optarg = argv[optind++]; return 1; } /* We have found another option-ARGV-element. Start decoding its characters. */ nextchar = (argv[optind] + 1 + (longopts != NULL && argv[optind][1] == '-')); } if (longopts != NULL && ((argv[optind][0] == '-' && (argv[optind][1] == '-' || long_only)) #ifdef GETOPT_COMPAT || argv[optind][0] == '+' #endif /* GETOPT_COMPAT */ )) { const struct option *p; char *s = nextchar; int exact = 0; int ambig = 0; const struct option *pfound = NULL; int indfound; while (*s && *s != '=') s++; /* Test all options for either exact match or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) if (!strncmp (p->name, nextchar, s - nextchar)) { if (s - nextchar == strlen (p->name)) { /* Exact match found. */ pfound = p; indfound = option_index; exact = 1; break; } else if (pfound == NULL) { /* First nonexact match found. */ pfound = p; indfound = option_index; } else /* Second nonexact match found. */ ambig = 1; } if (ambig && !exact) { if (opterr) fprintf (stderr, "%s: option `%s' is ambiguous\n", argv[0], argv[optind]); nextchar += strlen (nextchar); optind++; return '?'; } if (pfound != NULL) { option_index = indfound; optind++; if (*s) { /* Don't test has_arg with >, because some C compilers don't allow it to be used on enums. */ if (pfound->has_arg) optarg = s + 1; else { if (opterr) { if (argv[optind - 1][1] == '-') /* --option */ fprintf (stderr, "%s: option `--%s' doesn't allow an argument\n", argv[0], pfound->name); else /* +option or -option */ fprintf (stderr, "%s: option `%c%s' doesn't allow an argument\n", argv[0], argv[optind - 1][0], pfound->name); } nextchar += strlen (nextchar); return '?'; } } else if (pfound->has_arg == 1) { if (optind < argc) optarg = argv[optind++]; else { if (opterr) fprintf (stderr, "%s: option `%s' requires an argument\n", argv[0], argv[optind - 1]); nextchar += strlen (nextchar); return optstring[0] == ':' ? ':' : '?'; } } nextchar += strlen (nextchar); if (longind != NULL) *longind = option_index; if (pfound->flag) { *(pfound->flag) = pfound->val; return 0; } return pfound->val; } /* Can't find it as a long option. If this is not getopt_long_only, or the option starts with '--' or is not a valid short option, then it's an error. Otherwise interpret it as a short option. */ if (!long_only || argv[optind][1] == '-' #ifdef GETOPT_COMPAT || argv[optind][0] == '+' #endif /* GETOPT_COMPAT */ || my_index (optstring, *nextchar) == NULL) { if (opterr) { if (argv[optind][1] == '-') /* --option */ fprintf (stderr, "%s: unrecognized option `--%s'\n", argv[0], nextchar); else /* +option or -option */ fprintf (stderr, "%s: unrecognized option `%c%s'\n", argv[0], argv[optind][0], nextchar); } nextchar = (char *) ""; optind++; return '?'; } } /* Look at and handle the next option-character. */ { char c = *nextchar++; char *temp = my_index (optstring, c); /* Increment `optind' when we start to process its last character. */ if (*nextchar == '\0') ++optind; if (temp == NULL || c == ':') { if (opterr) { #if 0 if (c < 040 || c >= 0177) fprintf (stderr, "%s: unrecognized option, character code 0%o\n", argv[0], c); else fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c); #else /* 1003.2 specifies the format of this message. */ fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c); #endif } optopt = c; return '?'; } if (temp[1] == ':') { if (temp[2] == ':') { /* This is an option that accepts an argument optionally. */ if (*nextchar != '\0') { optarg = nextchar; optind++; } else optarg = 0; nextchar = NULL; } else { /* This is an option that requires an argument. */ if (*nextchar != '\0') { optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ optind++; } else if (optind == argc) { if (opterr) { #if 0 fprintf (stderr, "%s: option `-%c' requires an argument\n", argv[0], c); #else /* 1003.2 specifies the format of this message. */ fprintf (stderr, "%s: option requires an argument -- %c\n", argv[0], c); #endif } optopt = c; if (optstring[0] == ':') c = ':'; else c = '?'; } else /* We already incremented `optind' once; increment it again when taking next ARGV-elt as argument. */ optarg = argv[optind++]; nextchar = NULL; } } return c; } } int getopt (argc, argv, optstring) int argc; char *const *argv; const char *optstring; { return _getopt_internal (argc, argv, optstring, (const struct option *) 0, (int *) 0, 0); } #endif /* _LIBC or not __GNU_LIBRARY__. */ #ifdef TEST /* Compile with -DTEST to make an executable for use in testing the above definition of `getopt'. */ int main (argc, argv) int argc; char **argv; { int c; int digit_optind = 0; while (1) { int this_option_optind = optind ? optind : 1; c = getopt (argc, argv, "abc:d:0123456789"); if (c == EOF) break; switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (digit_optind != 0 && digit_optind != this_option_optind) printf ("digits occur in two different argv-elements.\n"); digit_optind = this_option_optind; printf ("option %c\n", c); break; case 'a': printf ("option a\n"); break; case 'b': printf ("option b\n"); break; case 'c': printf ("option c with value `%s'\n", optarg); break; case '?': break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } exit (0); } #endif /* TEST */ gdbm-1.7.2/getopt.h100600 24413 24 10474 5464676174 12705 0ustar downsjuser/* Declarations for getopt. Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _GETOPT_H #define _GETOPT_H 1 #ifdef __cplusplus extern "C" { #endif /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ extern char *optarg; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns EOF, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ extern int optind; /* Callers store zero here to inhibit the error message `getopt' prints for unrecognized options. */ extern int opterr; /* Set to an option character which was unrecognized. */ extern int optopt; /* Describe the long-named options requested by the application. The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector of `struct option' terminated by an element containing a name which is zero. The field `has_arg' is: no_argument (or 0) if the option does not take an argument, required_argument (or 1) if the option requires an argument, optional_argument (or 2) if the option takes an optional argument. If the field `flag' is not NULL, it points to a variable that is set to the value given in the field `val' when the option is found, but left unchanged if the option is not found. To have a long-named option do something other than set an `int' to a compiled-in constant, such as set a value from `optarg', set the option's `flag' field to zero and its `val' field to a nonzero value (the equivalent single-letter option character, if there is one). For long options that have a zero `flag' field, `getopt' returns the contents of the `val' field. */ struct option { #if __STDC__ const char *name; #else char *name; #endif /* has_arg can't be an enum because some compilers complain about type mismatches in all the code that assumes it is an int. */ int has_arg; int *flag; int val; }; /* Names for the values of the `has_arg' field of `struct option'. */ #define no_argument 0 #define required_argument 1 #define optional_argument 2 #if __STDC__ #if defined(__GNU_LIBRARY__) /* Many other libraries have conflicting prototypes for getopt, with differences in the consts, in stdlib.h. To avoid compilation errors, only prototype getopt for the GNU C library. */ extern int getopt (int argc, char *const *argv, const char *shortopts); #else /* not __GNU_LIBRARY__ */ extern int getopt (); #endif /* not __GNU_LIBRARY__ */ extern int getopt_long (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind); extern int getopt_long_only (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind); /* Internal only. Users should not call this directly. */ extern int _getopt_internal (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind, int long_only); #else /* not __STDC__ */ extern int getopt (); extern int getopt_long (); extern int getopt_long_only (); extern int _getopt_internal (); #endif /* not __STDC__ */ #ifdef __cplusplus } #endif #endif /* _GETOPT_H */ gdbm-1.7.2/samp1.cc100600 24413 24 1631 5404732642 12520 0ustar downsjuser// small c++ to open store then close a gdbm file // by Mike MacFaden 4/93 mike@premisys.com // tested with gdbm 1.5 and gnu v2.2 c++ compiler #include "iostream.h" #include "gdbm.h" extern int errno; /* C runtime library */ int main(int argc, char *argv[]) { cout << "Sample C++ program create a gdbm file ./tgdbm " << endl; GDBM_FILE pfile = gdbm_open("tstgdbm", 512, GDBM_WRCREAT, 00664, 0); if (!pfile) { cout << "main:gdbm_open " << gdbm_errno << errno << endl; return -1; } datum key = {"foo", strlen("foo")+1}; datum val = {"bar", strlen("bar")+1}; cout << "key is : " << key.dptr << endl; cout << "data is : " << val.dptr << endl; if (gdbm_store(pfile, key, val, GDBM_INSERT) != 0) { cout << "main:gdbm_store " << gdbm_errno << errno << endl; return -1; } gdbm_close(pfile); cout << "Sample C++ program complete" << endl; return 0; } gdbm-1.7.2/autoconf.h.in100600 24413 24 4240 5565365551 13574 0ustar downsjuser/* autoconf.h.in. Generated automatically from configure.in by autoheader. */ /* Define if using alloca.c. */ #undef C_ALLOCA /* Define to empty if the keyword does not work. */ #undef const /* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems. This function is required for alloca.c support on those systems. */ #undef CRAY_STACKSEG_END /* Define if you have alloca.h and it should be used (not Ultrix). */ #undef HAVE_ALLOCA_H /* Define if your struct stat has st_blksize. */ #undef HAVE_ST_BLKSIZE /* Define if int is 16 bits instead of 32. */ #undef INT_16_BITS /* Define if long int is 64 bits. */ #undef LONG_64_BITS /* Define to `long' if doesn't define. */ #undef off_t /* If using the C implementation of alloca, define if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #undef STACK_DIRECTION /* Define if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel and VAX). */ #undef WORDS_BIGENDIAN /* Define if you have bcopy. */ #undef HAVE_BCOPY /* Define if you have flock. */ #undef HAVE_FLOCK /* Define if you have fsync. */ #undef HAVE_FSYNC /* Define if you have ftruncate. */ #undef HAVE_FTRUNCATE /* Define if you have rename. */ #undef HAVE_RENAME /* Define if you have the header file. */ #undef HAVE_FCNTL_H /* Define if you have the header file. */ #undef HAVE_MEMORY_H /* Define if you have the header file. */ #undef HAVE_STDLIB_H /* Define if you have the header file. */ #undef HAVE_STRING_H /* Define if you have the header file. */ #undef HAVE_SYS_FILE_H /* Define if you have the header file. */ #undef HAVE_SYS_TYPES_H /* Define if you have the header file. */ #undef HAVE_UNISTD_H /* Define if you have the dbm library (-ldbm). */ #undef HAVE_LIBDBM /* Define if you have the ndbm library (-lndbm). */ #undef HAVE_LIBNDBM