Ignore:
Timestamp:
Mar 19, 2014, 11:11:30 AM (11 years ago)
Author:
dmik
Message:

python: Update vendor to 2.7.6.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • python/vendor/current/Modules/bsddbmodule.c

    r2 r388  
    3131
    3232typedef struct {
    33         PyObject_HEAD
    34         DB *di_bsddb;
    35         int di_size;    /* -1 means recompute */
    36         int di_type;
    37 #ifdef WITH_THREAD
    38         PyThread_type_lock di_lock;
     33    PyObject_HEAD
     34    DB *di_bsddb;
     35    int di_size;        /* -1 means recompute */
     36    int di_type;
     37#ifdef WITH_THREAD
     38    PyThread_type_lock di_lock;
    3939#endif
    4040} bsddbobject;
    … …  
    4545#define check_bsddbobject_open(v, r) if ((v)->di_bsddb == NULL) \
    4646               { PyErr_SetString(BsddbError, \
    47                                 "BSDDB object has already been closed"); \
     47                                "BSDDB object has already been closed"); \
    4848                 return r; }
    4949
    … …  
    5252static PyObject *
    5353newdbhashobject(char *file, int flags, int mode,
    54                 int bsize, int ffactor, int nelem, int cachesize,
    55                 int hash, int lorder)
    56 {
    57         bsddbobject *dp;
    58         HASHINFO info;
    59 
    60         if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
    61                 return NULL;
    62 
    63         info.bsize = bsize;
    64         info.ffactor = ffactor;
    65         info.nelem = nelem;
    66         info.cachesize = cachesize;
    67         info.hash = NULL; /* XXX should derive from hash argument */
    68         info.lorder = lorder;
     54                int bsize, int ffactor, int nelem, int cachesize,
     55                int hash, int lorder)
     56{
     57    bsddbobject *dp;
     58    HASHINFO info;
     59
     60    if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
     61        return NULL;
     62
     63    info.bsize = bsize;
     64    info.ffactor = ffactor;
     65    info.nelem = nelem;
     66    info.cachesize = cachesize;
     67    info.hash = NULL; /* XXX should derive from hash argument */
     68    info.lorder = lorder;
    6969
    7070#ifdef O_BINARY
    71         flags |= O_BINARY;
    72 #endif
    73         Py_BEGIN_ALLOW_THREADS
    74         dp->di_bsddb = dbopen(file, flags, mode, DB_HASH, &info);
    75         Py_END_ALLOW_THREADS
    76         if (dp->di_bsddb == NULL) {
    77                 PyErr_SetFromErrno(BsddbError);
    78 #ifdef WITH_THREAD
    79                 dp->di_lock = NULL;
    80 #endif
    81                 Py_DECREF(dp);
    82                 return NULL;
    83         }
    84 
    85         dp->di_size = -1;
    86         dp->di_type = DB_HASH;
    87 
    88 #ifdef WITH_THREAD
    89         dp->di_lock = PyThread_allocate_lock();
    90         if (dp->di_lock == NULL) {
    91                 PyErr_SetString(BsddbError, "can't allocate lock");
    92                 Py_DECREF(dp);
    93                 return NULL;
    94         }
    95 #endif
    96 
    97         return (PyObject *)dp;
     71    flags |= O_BINARY;
     72#endif
     73    Py_BEGIN_ALLOW_THREADS
     74    dp->di_bsddb = dbopen(file, flags, mode, DB_HASH, &info);
     75    Py_END_ALLOW_THREADS
     76    if (dp->di_bsddb == NULL) {
     77        PyErr_SetFromErrno(BsddbError);
     78#ifdef WITH_THREAD
     79        dp->di_lock = NULL;
     80#endif
     81        Py_DECREF(dp);
     82        return NULL;
     83    }
     84
     85    dp->di_size = -1;
     86    dp->di_type = DB_HASH;
     87
     88#ifdef WITH_THREAD
     89    dp->di_lock = PyThread_allocate_lock();
     90    if (dp->di_lock == NULL) {
     91        PyErr_SetString(BsddbError, "can't allocate lock");
     92        Py_DECREF(dp);
     93        return NULL;
     94    }
     95#endif
     96
     97    return (PyObject *)dp;
    9898}
    9999
    100100static PyObject *
    101101newdbbtobject(char *file, int flags, int mode,
    102               int btflags, int cachesize, int maxkeypage,
    103               int minkeypage, int psize, int lorder)
    104 {
    105         bsddbobject *dp;
    106         BTREEINFO info;
    107 
    108         if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
    109                 return NULL;
    110 
    111         info.flags = btflags;
    112         info.cachesize = cachesize;
    113         info.maxkeypage = maxkeypage;
    114         info.minkeypage = minkeypage;
    115         info.psize = psize;
    116         info.lorder = lorder;
    117         info.compare = 0; /* Use default comparison functions, for now..*/
    118         info.prefix = 0;
     102              int btflags, int cachesize, int maxkeypage,
     103              int minkeypage, int psize, int lorder)
     104{
     105    bsddbobject *dp;
     106    BTREEINFO info;
     107
     108    if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
     109        return NULL;
     110
     111    info.flags = btflags;
     112    info.cachesize = cachesize;
     113    info.maxkeypage = maxkeypage;
     114    info.minkeypage = minkeypage;
     115    info.psize = psize;
     116    info.lorder = lorder;
     117    info.compare = 0; /* Use default comparison functions, for now..*/
     118    info.prefix = 0;
    119119
    120120#ifdef O_BINARY
    121         flags |= O_BINARY;
    122 #endif
    123         Py_BEGIN_ALLOW_THREADS
    124         dp->di_bsddb = dbopen(file, flags, mode, DB_BTREE, &info);
    125         Py_END_ALLOW_THREADS
    126         if (dp->di_bsddb == NULL) {
    127                 PyErr_SetFromErrno(BsddbError);
    128 #ifdef WITH_THREAD
    129                 dp->di_lock = NULL;
    130 #endif
    131                 Py_DECREF(dp);
    132                 return NULL;
    133         }
    134 
    135         dp->di_size = -1;
    136         dp->di_type = DB_BTREE;
    137 
    138 #ifdef WITH_THREAD
    139         dp->di_lock = PyThread_allocate_lock();
    140         if (dp->di_lock == NULL) {
    141                 PyErr_SetString(BsddbError, "can't allocate lock");
    142                 Py_DECREF(dp);
    143                 return NULL;
    144         }
    145 #endif
    146 
    147         return (PyObject *)dp;
     121    flags |= O_BINARY;
     122#endif
     123    Py_BEGIN_ALLOW_THREADS
     124    dp->di_bsddb = dbopen(file, flags, mode, DB_BTREE, &info);
     125    Py_END_ALLOW_THREADS
     126    if (dp->di_bsddb == NULL) {
     127        PyErr_SetFromErrno(BsddbError);
     128#ifdef WITH_THREAD
     129        dp->di_lock = NULL;
     130#endif
     131        Py_DECREF(dp);
     132        return NULL;
     133    }
     134
     135    dp->di_size = -1;
     136    dp->di_type = DB_BTREE;
     137
     138#ifdef WITH_THREAD
     139    dp->di_lock = PyThread_allocate_lock();
     140    if (dp->di_lock == NULL) {
     141        PyErr_SetString(BsddbError, "can't allocate lock");
     142        Py_DECREF(dp);
     143        return NULL;
     144    }
     145#endif
     146
     147    return (PyObject *)dp;
    148148}
    149149
    150150static PyObject *
    151151newdbrnobject(char *file, int flags, int mode,
    152               int rnflags, int cachesize, int psize, int lorder,
    153               size_t reclen, u_char bval, char *bfname)
    154 {
    155         bsddbobject *dp;
    156         RECNOINFO info;
    157         int fd;
    158 
    159         if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
    160                 return NULL;
    161 
    162         info.flags = rnflags;
    163         info.cachesize = cachesize;
    164         info.psize = psize;
    165         info.lorder = lorder;
    166         info.reclen = reclen;
    167         info.bval = bval;
    168         info.bfname = bfname;
     152              int rnflags, int cachesize, int psize, int lorder,
     153              size_t reclen, u_char bval, char *bfname)
     154{
     155    bsddbobject *dp;
     156    RECNOINFO info;
     157    int fd;
     158
     159    if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
     160        return NULL;
     161
     162    info.flags = rnflags;
     163    info.cachesize = cachesize;
     164    info.psize = psize;
     165    info.lorder = lorder;
     166    info.reclen = reclen;
     167    info.bval = bval;
     168    info.bfname = bfname;
    169169
    170170#ifdef O_BINARY
    171         flags |= O_BINARY;
    172 #endif
    173         /* This is a hack to avoid a dbopen() bug that happens when
    174         * it fails. */
    175         fd = open(file, flags);
    176         if (fd == -1) {
    177                 dp->di_bsddb = NULL;
    178         }
    179         else {
    180                 close(fd);
    181                 Py_BEGIN_ALLOW_THREADS
    182                 dp->di_bsddb = dbopen(file, flags, mode, DB_RECNO, &info);
    183                 Py_END_ALLOW_THREADS
    184         }
    185         if (dp->di_bsddb == NULL) {
    186                 PyErr_SetFromErrno(BsddbError);
    187 #ifdef WITH_THREAD
    188                 dp->di_lock = NULL;
    189 #endif
    190                 Py_DECREF(dp);
    191                 return NULL;
    192         }
    193 
    194         dp->di_size = -1;
    195         dp->di_type = DB_RECNO;
    196 
    197 #ifdef WITH_THREAD
    198         dp->di_lock = PyThread_allocate_lock();
    199         if (dp->di_lock == NULL) {
    200                 PyErr_SetString(BsddbError, "can't allocate lock");
    201                 Py_DECREF(dp);
    202                 return NULL;
    203         }
    204 #endif
    205 
    206         return (PyObject *)dp;
     171    flags |= O_BINARY;
     172#endif
     173    /* This is a hack to avoid a dbopen() bug that happens when
     174    * it fails. */
     175    fd = open(file, flags);
     176    if (fd == -1) {
     177        dp->di_bsddb = NULL;
     178    }
     179    else {
     180        close(fd);
     181        Py_BEGIN_ALLOW_THREADS
     182        dp->di_bsddb = dbopen(file, flags, mode, DB_RECNO, &info);
     183        Py_END_ALLOW_THREADS
     184    }
     185    if (dp->di_bsddb == NULL) {
     186        PyErr_SetFromErrno(BsddbError);
     187#ifdef WITH_THREAD
     188        dp->di_lock = NULL;
     189#endif
     190        Py_DECREF(dp);
     191        return NULL;
     192    }
     193
     194    dp->di_size = -1;
     195    dp->di_type = DB_RECNO;
     196
     197#ifdef WITH_THREAD
     198    dp->di_lock = PyThread_allocate_lock();
     199    if (dp->di_lock == NULL) {
     200        PyErr_SetString(BsddbError, "can't allocate lock");
     201        Py_DECREF(dp);
     202        return NULL;
     203    }
     204#endif
     205
     206    return (PyObject *)dp;
    207207}
    208208
    … …  
    211211{
    212212#ifdef WITH_THREAD
    213         if (dp->di_lock) {
    214                 PyThread_acquire_lock(dp->di_lock, 0);
    215                 PyThread_release_lock(dp->di_lock);
    216                 PyThread_free_lock(dp->di_lock);
    217                 dp->di_lock = NULL;
    218         }
    219 #endif
    220         if (dp->di_bsddb != NULL) {
    221                 int status;
    222                 Py_BEGIN_ALLOW_THREADS
    223                 status = (dp->di_bsddb->close)(dp->di_bsddb);
    224                 Py_END_ALLOW_THREADS
    225                 if (status != 0)
    226                         fprintf(stderr,
    227                                 "Python bsddb: close errno %d in dealloc\n",
    228                                 errno);
    229         }
    230         PyObject_Del(dp);
     213    if (dp->di_lock) {
     214        PyThread_acquire_lock(dp->di_lock, 0);
     215        PyThread_release_lock(dp->di_lock);
     216        PyThread_free_lock(dp->di_lock);
     217        dp->di_lock = NULL;
     218    }
     219#endif
     220    if (dp->di_bsddb != NULL) {
     221        int status;
     222        Py_BEGIN_ALLOW_THREADS
     223        status = (dp->di_bsddb->close)(dp->di_bsddb);
     224        Py_END_ALLOW_THREADS
     225        if (status != 0)
     226            fprintf(stderr,
     227                "Python bsddb: close errno %d in dealloc\n",
     228                errno);
     229    }
     230    PyObject_Del(dp);
    231231}
    232232
    233233#ifdef WITH_THREAD
    234234#define BSDDB_BGN_SAVE(_dp) \
    235         Py_BEGIN_ALLOW_THREADS PyThread_acquire_lock(_dp->di_lock,1);
     235    Py_BEGIN_ALLOW_THREADS PyThread_acquire_lock(_dp->di_lock,1);
    236236#define BSDDB_END_SAVE(_dp) \
    237         PyThread_release_lock(_dp->di_lock); Py_END_ALLOW_THREADS
     237    PyThread_release_lock(_dp->di_lock); Py_END_ALLOW_THREADS
    238238#else
    239 #define BSDDB_BGN_SAVE(_dp) Py_BEGIN_ALLOW_THREADS 
     239#define BSDDB_BGN_SAVE(_dp) Py_BEGIN_ALLOW_THREADS
    240240#define BSDDB_END_SAVE(_dp) Py_END_ALLOW_THREADS
    241241#endif
    … …  
    244244bsddb_length(bsddbobject *dp)
    245245{
    246         check_bsddbobject_open(dp, -1);
    247         if (dp->di_size < 0) {
    248                 DBT krec, drec;
    249                 int status;
    250                 int size = 0;
    251                 BSDDB_BGN_SAVE(dp)
    252                 for (status = (dp->di_bsddb->seq)(dp->di_bsddb,
    253                                                   &krec, &drec,R_FIRST);
    254                      status == 0;
    255                      status = (dp->di_bsddb->seq)(dp->di_bsddb,
    256                                                   &krec, &drec, R_NEXT))
    257                         size++;
    258                 BSDDB_END_SAVE(dp)
    259                 if (status < 0) {
    260                         PyErr_SetFromErrno(BsddbError);
    261                         return -1;
    262                 }
    263                 dp->di_size = size;
    264         }
    265         return dp->di_size;
     246    check_bsddbobject_open(dp, -1);
     247    if (dp->di_size < 0) {
     248        DBT krec, drec;
     249        int status;
     250        int size = 0;
     251        BSDDB_BGN_SAVE(dp)
     252        for (status = (dp->di_bsddb->seq)(dp->di_bsddb,
     253                                          &krec, &drec,R_FIRST);
     254             status == 0;
     255             status = (dp->di_bsddb->seq)(dp->di_bsddb,
     256                                          &krec, &drec, R_NEXT))
     257            size++;
     258        BSDDB_END_SAVE(dp)
     259        if (status < 0) {
     260            PyErr_SetFromErrno(BsddbError);
     261            return -1;
     262        }
     263        dp->di_size = size;
     264    }
     265    return dp->di_size;
    266266}
    267267
    … …  
    269269bsddb_subscript(bsddbobject *dp, PyObject *key)
    270270{
    271         int status;
    272         DBT krec, drec;
    273         char *data,buf[4096];
    274         int size;
    275         PyObject *result;
    276         recno_t recno;
    277        
    278         if (dp->di_type == DB_RECNO) {
    279                 if (!PyArg_Parse(key, "i", &recno)) {
    280                         PyErr_SetString(PyExc_TypeError,
    281                                         "key type must be integer");
    282                         return NULL;
    283                 }
    284                 krec.data = &recno;
    285                 krec.size = sizeof(recno);
    286         }
    287         else {
    288                 if (!PyArg_Parse(key, "s#", &data, &size)) {
    289                         PyErr_SetString(PyExc_TypeError,
    290                                         "key type must be string");
    291                         return NULL;
    292                 }
    293                 krec.data = data;
    294                 krec.size = size;
    295         }
    296         check_bsddbobject_open(dp, NULL);
    297 
    298         BSDDB_BGN_SAVE(dp)
    299         status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
    300         if (status == 0) {
    301                 if (drec.size > sizeof(buf)) data = malloc(drec.size);
    302                 else data = buf;
    303                 if (data!=NULL) memcpy(data,drec.data,drec.size);
    304         }
    305         BSDDB_END_SAVE(dp)
    306         if (data==NULL) return PyErr_NoMemory();
    307         if (status != 0) {
    308                 if (status < 0)
    309                         PyErr_SetFromErrno(BsddbError);
    310                 else
    311                         PyErr_SetObject(PyExc_KeyError, key);
    312                 return NULL;
    313         }
    314 
    315         result = PyString_FromStringAndSize(data, (int)drec.size);
    316         if (data != buf) free(data);
    317         return result;
     271    int status;
     272    DBT krec, drec;
     273    char *data = NULL;
     274    char buf[4096];
     275    int size;
     276    PyObject *result;
     277    recno_t recno;
     278
     279    if (dp->di_type == DB_RECNO) {
     280        if (!PyArg_Parse(key, "i", &recno)) {
     281            PyErr_SetString(PyExc_TypeError,
     282                            "key type must be integer");
     283            return NULL;
     284        }
     285        krec.data = &recno;
     286        krec.size = sizeof(recno);
     287    }
     288    else {
     289        if (!PyArg_Parse(key, "s#", &data, &size)) {
     290            PyErr_SetString(PyExc_TypeError,
     291                            "key type must be string");
     292            return NULL;
     293        }
     294        krec.data = data;
     295        krec.size = size;
     296    }
     297    check_bsddbobject_open(dp, NULL);
     298
     299    BSDDB_BGN_SAVE(dp)
     300    status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
     301    if (status == 0) {
     302        if (drec.size > sizeof(buf)) data = malloc(drec.size);
     303        else data = buf;
     304        if (data!=NULL) memcpy(data,drec.data,drec.size);
     305    }
     306    BSDDB_END_SAVE(dp)
     307    if (data==NULL) return PyErr_NoMemory();
     308    if (status != 0) {
     309        if (status < 0)
     310            PyErr_SetFromErrno(BsddbError);
     311        else
     312            PyErr_SetObject(PyExc_KeyError, key);
     313        return NULL;
     314    }
     315
     316    result = PyString_FromStringAndSize(data, (int)drec.size);
     317    if (data != buf) free(data);
     318    return result;
    318319}
    319320
    … …  
    321322bsddb_ass_sub(bsddbobject *dp, PyObject *key, PyObject *value)
    322323{
    323         int status;
    324         DBT krec, drec;
    325         char *data;
    326         int size;
    327         recno_t recno;
    328 
    329         if (dp->di_type == DB_RECNO) {
    330                 if (!PyArg_Parse(key, "i", &recno)) {
    331                         PyErr_SetString(PyExc_TypeError,
    332                                         "bsddb key type must be integer");
    333                         return -1;
    334                 }
    335                 krec.data = &recno;
    336                 krec.size = sizeof(recno);
    337         }
    338         else {
    339                 if (!PyArg_Parse(key, "s#", &data, &size)) {
    340                         PyErr_SetString(PyExc_TypeError,
    341                                         "bsddb key type must be string");
    342                         return -1;
    343                 }
    344                 krec.data = data;
    345                 krec.size = size;
    346         }
    347         check_bsddbobject_open(dp, -1);
    348         dp->di_size = -1;
    349         if (value == NULL) {
    350                 BSDDB_BGN_SAVE(dp)
    351                 status = (dp->di_bsddb->del)(dp->di_bsddb, &krec, 0);
    352                 BSDDB_END_SAVE(dp)
    353         }
    354         else {
    355                 if (!PyArg_Parse(value, "s#", &data, &size)) {
    356                         PyErr_SetString(PyExc_TypeError,
    357                                         "bsddb value type must be string");
    358                         return -1;
    359                 }
    360                 drec.data = data;
    361                 drec.size = size;
    362                 BSDDB_BGN_SAVE(dp)
    363                 status = (dp->di_bsddb->put)(dp->di_bsddb, &krec, &drec, 0);
    364                 BSDDB_END_SAVE(dp)
    365         }
    366         if (status != 0) {
    367                 if (status < 0)
    368                         PyErr_SetFromErrno(BsddbError);
    369                 else
    370                         PyErr_SetObject(PyExc_KeyError, key);
    371                 return -1;
    372         }
    373         return 0;
     324    int status;
     325    DBT krec, drec;
     326    char *data;
     327    int size;
     328    recno_t recno;
     329
     330    if (dp->di_type == DB_RECNO) {
     331        if (!PyArg_Parse(key, "i", &recno)) {
     332            PyErr_SetString(PyExc_TypeError,
     333                            "bsddb key type must be integer");
     334            return -1;
     335        }
     336        krec.data = &recno;
     337        krec.size = sizeof(recno);
     338    }
     339    else {
     340        if (!PyArg_Parse(key, "s#", &data, &size)) {
     341            PyErr_SetString(PyExc_TypeError,
     342                            "bsddb key type must be string");
     343            return -1;
     344        }
     345        krec.data = data;
     346        krec.size = size;
     347    }
     348    check_bsddbobject_open(dp, -1);
     349    dp->di_size = -1;
     350    if (value == NULL) {
     351        BSDDB_BGN_SAVE(dp)
     352        status = (dp->di_bsddb->del)(dp->di_bsddb, &krec, 0);
     353        BSDDB_END_SAVE(dp)
     354    }
     355    else {
     356        if (!PyArg_Parse(value, "s#", &data, &size)) {
     357            PyErr_SetString(PyExc_TypeError,
     358                            "bsddb value type must be string");
     359            return -1;
     360        }
     361        drec.data = data;
     362        drec.size = size;
     363        BSDDB_BGN_SAVE(dp)
     364        status = (dp->di_bsddb->put)(dp->di_bsddb, &krec, &drec, 0);
     365        BSDDB_END_SAVE(dp)
     366    }
     367    if (status != 0) {
     368        if (status < 0)
     369            PyErr_SetFromErrno(BsddbError);
     370        else
     371            PyErr_SetObject(PyExc_KeyError, key);
     372        return -1;
     373    }
     374    return 0;
    374375}
    375376
    376377static PyMappingMethods bsddb_as_mapping = {
    377         (lenfunc)bsddb_length,          /*mp_length*/
    378         (binaryfunc)bsddb_subscript,    /*mp_subscript*/
    379         (objobjargproc)bsddb_ass_sub,   /*mp_ass_subscript*/
     378    (lenfunc)bsddb_length,              /*mp_length*/
     379    (binaryfunc)bsddb_subscript,        /*mp_subscript*/
     380    (objobjargproc)bsddb_ass_sub,       /*mp_ass_subscript*/
    380381};
    381382
    … …  
    383384bsddb_close(bsddbobject *dp)
    384385{
    385         if (dp->di_bsddb != NULL) {
    386                 int status;
    387                 BSDDB_BGN_SAVE(dp)
    388                 status = (dp->di_bsddb->close)(dp->di_bsddb);
    389                 BSDDB_END_SAVE(dp)
    390                 if (status != 0) {
    391                         dp->di_bsddb = NULL;
    392                         PyErr_SetFromErrno(BsddbError);
    393                         return NULL;
    394                 }
    395         }
    396         dp->di_bsddb = NULL;
    397         Py_INCREF(Py_None);
    398         return Py_None;
     386    if (dp->di_bsddb != NULL) {
     387        int status;
     388        BSDDB_BGN_SAVE(dp)
     389        status = (dp->di_bsddb->close)(dp->di_bsddb);
     390        BSDDB_END_SAVE(dp)
     391        if (status != 0) {
     392            dp->di_bsddb = NULL;
     393            PyErr_SetFromErrno(BsddbError);
     394            return NULL;
     395        }
     396    }
     397    dp->di_bsddb = NULL;
     398    Py_INCREF(Py_None);
     399    return Py_None;
    399400}
    400401
    … …  
    402403bsddb_keys(bsddbobject *dp)
    403404{
    404         PyObject *list, *item=NULL;
    405         DBT krec, drec;
    406         char *data=NULL,buf[4096];
    407         int status;
    408         int err;
    409 
    410         check_bsddbobject_open(dp, NULL);
    411         list = PyList_New(0);
    412         if (list == NULL)
    413                 return NULL;
    414         BSDDB_BGN_SAVE(dp)
    415         status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_FIRST);
    416         if (status == 0) {
    417                 if (krec.size > sizeof(buf)) data = malloc(krec.size);
    418                 else data = buf;
    419                 if (data != NULL) memcpy(data,krec.data,krec.size);
    420         }
    421         BSDDB_END_SAVE(dp)
    422         if (status == 0 && data==NULL) return PyErr_NoMemory();
    423         while (status == 0) {
    424                 if (dp->di_type == DB_RECNO)
    425                         item = PyInt_FromLong(*((int*)data));
    426                 else
    427                         item = PyString_FromStringAndSize(data,
    428                                                           (int)krec.size);
    429                 if (data != buf) free(data);
    430                 if (item == NULL) {
    431                         Py_DECREF(list);
    432                         return NULL;
    433                 }
    434                 err = PyList_Append(list, item);
    435                 Py_DECREF(item);
    436                 if (err != 0) {
    437                         Py_DECREF(list);
    438                         return NULL;
    439                 }
    440                 BSDDB_BGN_SAVE(dp)
    441                 status = (dp->di_bsddb->seq)
    442                         (dp->di_bsddb, &krec, &drec, R_NEXT);
    443                 if (status == 0) {
    444                         if (krec.size > sizeof(buf))
    445                                 data = malloc(krec.size);
    446                         else data = buf;
    447                         if (data != NULL)
    448                                 memcpy(data,krec.data,krec.size);
    449                 }
    450                 BSDDB_END_SAVE(dp)
    451                 if (data == NULL) return PyErr_NoMemory();
    452         }
    453         if (status < 0) {
    454                 PyErr_SetFromErrno(BsddbError);
    455                 Py_DECREF(list);
    456                 return NULL;
    457         }
    458         if (dp->di_size < 0)
    459                 dp->di_size = PyList_Size(list); /* We just did the work */
    460         return list;
     405    PyObject *list, *item=NULL;
     406    DBT krec, drec;
     407    char *data=NULL,buf[4096];
     408    int status;
     409    int err;
     410
     411    check_bsddbobject_open(dp, NULL);
     412    list = PyList_New(0);
     413    if (list == NULL)
     414        return NULL;
     415    BSDDB_BGN_SAVE(dp)
     416    status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_FIRST);
     417    if (status == 0) {
     418        if (krec.size > sizeof(buf)) data = malloc(krec.size);
     419        else data = buf;
     420        if (data != NULL) memcpy(data,krec.data,krec.size);
     421    }
     422    BSDDB_END_SAVE(dp)
     423    if (status == 0 && data==NULL) return PyErr_NoMemory();
     424    while (status == 0) {
     425        if (dp->di_type == DB_RECNO)
     426            item = PyInt_FromLong(*((int*)data));
     427        else
     428            item = PyString_FromStringAndSize(data,
     429                                              (int)krec.size);
     430        if (data != buf) free(data);
     431        if (item == NULL) {
     432            Py_DECREF(list);
     433            return NULL;
     434        }
     435        err = PyList_Append(list, item);
     436        Py_DECREF(item);
     437        if (err != 0) {
     438            Py_DECREF(list);
     439            return NULL;
     440        }
     441        BSDDB_BGN_SAVE(dp)
     442        status = (dp->di_bsddb->seq)
     443            (dp->di_bsddb, &krec, &drec, R_NEXT);
     444        if (status == 0) {
     445            if (krec.size > sizeof(buf))
     446                data = malloc(krec.size);
     447            else data = buf;
     448            if (data != NULL)
     449                memcpy(data,krec.data,krec.size);
     450        }
     451        BSDDB_END_SAVE(dp)
     452        if (data == NULL) return PyErr_NoMemory();
     453    }
     454    if (status < 0) {
     455        PyErr_SetFromErrno(BsddbError);
     456        Py_DECREF(list);
     457        return NULL;
     458    }
     459    if (dp->di_size < 0)
     460        dp->di_size = PyList_Size(list); /* We just did the work */
     461    return list;
    461462}
    462463
    … …  
    464465bsddb_has_key(bsddbobject *dp, PyObject *args)
    465466{
    466         DBT krec, drec;
    467         int status;
    468         char *data;
    469         int size;
    470         recno_t recno;
    471 
    472         if (dp->di_type == DB_RECNO) {
    473                 if (!PyArg_ParseTuple(args, "i;key type must be integer",
    474                                       &recno)) {
    475                         return NULL;
    476                 }
    477                 krec.data = &recno;
    478                 krec.size = sizeof(recno);
    479         }
    480         else {
    481                 if (!PyArg_ParseTuple(args, "s#;key type must be string",
    482                                       &data, &size)) {
    483                         return NULL;
    484                 }
    485                 krec.data = data;
    486                 krec.size = size;
    487         }
    488         check_bsddbobject_open(dp, NULL);
    489 
    490         BSDDB_BGN_SAVE(dp)
    491         status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
    492         BSDDB_END_SAVE(dp)
    493         if (status < 0) {
    494                 PyErr_SetFromErrno(BsddbError);
    495                 return NULL;
    496         }
    497 
    498         return PyInt_FromLong(status == 0);
     467    DBT krec, drec;
     468    int status;
     469    char *data;
     470    int size;
     471    recno_t recno;
     472
     473    if (dp->di_type == DB_RECNO) {
     474        if (!PyArg_ParseTuple(args, "i;key type must be integer",
     475                              &recno)) {
     476            return NULL;
     477        }
     478        krec.data = &recno;
     479        krec.size = sizeof(recno);
     480    }
     481    else {
     482        if (!PyArg_ParseTuple(args, "s#;key type must be string",
     483                              &data, &size)) {
     484            return NULL;
     485        }
     486        krec.data = data;
     487        krec.size = size;
     488    }
     489    check_bsddbobject_open(dp, NULL);
     490
     491    BSDDB_BGN_SAVE(dp)
     492    status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
     493    BSDDB_END_SAVE(dp)
     494    if (status < 0) {
     495        PyErr_SetFromErrno(BsddbError);
     496        return NULL;
     497    }
     498
     499    return PyInt_FromLong(status == 0);
    499500}
    500501
    … …  
    502503bsddb_set_location(bsddbobject *dp, PyObject *key)
    503504{
    504         int status;
    505         DBT krec, drec;
    506         char *data,buf[4096];
    507         int size;
    508         PyObject *result;
    509         recno_t recno;
    510 
    511         if (dp->di_type == DB_RECNO) {
    512                 if (!PyArg_ParseTuple(key, "i;key type must be integer",
    513                                       &recno)) {
    514                         return NULL;
    515                 }
    516                 krec.data = &recno;
    517                 krec.size = sizeof(recno);
    518         }
    519         else {
    520                 if (!PyArg_ParseTuple(key, "s#;key type must be string",
    521                                       &data, &size)) {
    522                         return NULL;
    523                 }
    524                 krec.data = data;
    525                 krec.size = size;
    526         }
    527         check_bsddbobject_open(dp, NULL);
    528 
    529         BSDDB_BGN_SAVE(dp)
    530         status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_CURSOR);
    531         if (status == 0) {
    532                 if (drec.size > sizeof(buf)) data = malloc(drec.size);
    533                 else data = buf;
    534                 if (data!=NULL) memcpy(data,drec.data,drec.size);
    535         }
    536         BSDDB_END_SAVE(dp)
    537         if (data==NULL) return PyErr_NoMemory();
    538         if (status != 0) {
    539                 if (status < 0)
    540                         PyErr_SetFromErrno(BsddbError);
    541                 else
    542                         PyErr_SetObject(PyExc_KeyError, key);
    543                 return NULL;
    544         }
    545 
    546         if (dp->di_type == DB_RECNO)
    547                 result = Py_BuildValue("is#", *((int*)krec.data),
    548                                        data, drec.size);
    549         else
    550                 result = Py_BuildValue("s#s#", krec.data, krec.size,
    551                                        data, drec.size);
    552         if (data != buf) free(data);
    553         return result;
     505    int status;
     506    DBT krec, drec;
     507    char *data = NULL;
     508    char buf[4096];
     509    int size;
     510    PyObject *result;
     511    recno_t recno;
     512
     513    if (dp->di_type == DB_RECNO) {
     514        if (!PyArg_ParseTuple(key, "i;key type must be integer",
     515                              &recno)) {
     516            return NULL;
     517        }
     518        krec.data = &recno;
     519        krec.size = sizeof(recno);
     520    }
     521    else {
     522        if (!PyArg_ParseTuple(key, "s#;key type must be string",
     523                              &data, &size)) {
     524            return NULL;
     525        }
     526        krec.data = data;
     527        krec.size = size;
     528    }
     529    check_bsddbobject_open(dp, NULL);
     530
     531    BSDDB_BGN_SAVE(dp)
     532    status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_CURSOR);
     533    if (status == 0) {
     534        if (drec.size > sizeof(buf)) data = malloc(drec.size);
     535        else data = buf;
     536        if (data!=NULL) memcpy(data,drec.data,drec.size);
     537    }
     538    BSDDB_END_SAVE(dp)
     539    if (data==NULL) return PyErr_NoMemory();
     540    if (status != 0) {
     541        if (status < 0)
     542            PyErr_SetFromErrno(BsddbError);
     543        else
     544            PyErr_SetObject(PyExc_KeyError, key);
     545        return NULL;
     546    }
     547
     548    if (dp->di_type == DB_RECNO)
     549        result = Py_BuildValue("is#", *((int*)krec.data),
     550                               data, drec.size);
     551    else
     552        result = Py_BuildValue("s#s#", krec.data, krec.size,
     553                               data, drec.size);
     554    if (data != buf) free(data);
     555    return result;
    554556}
    555557
    … …  
    557559bsddb_seq(bsddbobject *dp, int sequence_request)
    558560{
    559         int status;
    560         DBT krec, drec;
    561         char *kdata=NULL,kbuf[4096];
    562         char *ddata=NULL,dbuf[4096];
    563         PyObject *result;
    564 
    565         check_bsddbobject_open(dp, NULL);
    566         krec.data = 0;
    567         krec.size = 0;
    568 
    569         BSDDB_BGN_SAVE(dp)
    570         status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec,
    571                                      &drec, sequence_request);
    572         if (status == 0) {
    573                 if (krec.size > sizeof(kbuf)) kdata = malloc(krec.size);
    574                 else kdata = kbuf;
    575                 if (kdata != NULL) memcpy(kdata,krec.data,krec.size);
    576                 if (drec.size > sizeof(dbuf)) ddata = malloc(drec.size);
    577                 else ddata = dbuf;
    578                 if (ddata != NULL) memcpy(ddata,drec.data,drec.size);
    579         }
    580         BSDDB_END_SAVE(dp)
    581         if (status == 0) {
    582                 if ((kdata == NULL) || (ddata == NULL))
    583                         return PyErr_NoMemory();
    584         }
    585         else {
    586                 /* (status != 0) */ 
    587                 if (status < 0)
    588                         PyErr_SetFromErrno(BsddbError);
    589                 else
    590                         PyErr_SetString(PyExc_KeyError, "no key/data pairs");
    591                 return NULL;
    592         }
    593 
    594         if (dp->di_type == DB_RECNO)
    595                 result = Py_BuildValue("is#", *((int*)kdata),
    596                                        ddata, drec.size);
    597         else
    598                 result = Py_BuildValue("s#s#", kdata, krec.size,
    599                                        ddata, drec.size);
    600         if (kdata != kbuf) free(kdata);
    601         if (ddata != dbuf) free(ddata);
    602         return result;
     561    int status;
     562    DBT krec, drec;
     563    char *kdata=NULL,kbuf[4096];
     564    char *ddata=NULL,dbuf[4096];
     565    PyObject *result;
     566
     567    check_bsddbobject_open(dp, NULL);
     568    krec.data = 0;
     569    krec.size = 0;
     570
     571    BSDDB_BGN_SAVE(dp)
     572    status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec,
     573                                 &drec, sequence_request);
     574    if (status == 0) {
     575        if (krec.size > sizeof(kbuf)) kdata = malloc(krec.size);
     576        else kdata = kbuf;
     577        if (kdata != NULL) memcpy(kdata,krec.data,krec.size);
     578        if (drec.size > sizeof(dbuf)) ddata = malloc(drec.size);
     579        else ddata = dbuf;
     580        if (ddata != NULL) memcpy(ddata,drec.data,drec.size);
     581    }
     582    BSDDB_END_SAVE(dp)
     583    if (status == 0) {
     584        if ((kdata == NULL) || (ddata == NULL))
     585            return PyErr_NoMemory();
     586    }
     587    else {
     588        /* (status != 0) */
     589        if (status < 0)
     590            PyErr_SetFromErrno(BsddbError);
     591        else
     592            PyErr_SetString(PyExc_KeyError, "no key/data pairs");
     593        return NULL;
     594    }
     595
     596    if (dp->di_type == DB_RECNO)
     597        result = Py_BuildValue("is#", *((int*)kdata),
     598                               ddata, drec.size);
     599    else
     600        result = Py_BuildValue("s#s#", kdata, krec.size,
     601                               ddata, drec.size);
     602    if (kdata != kbuf) free(kdata);
     603    if (ddata != dbuf) free(ddata);
     604    return result;
    603605}
    604606
    … …  
    606608bsddb_next(bsddbobject *dp)
    607609{
    608         return bsddb_seq(dp, R_NEXT);
     610    return bsddb_seq(dp, R_NEXT);
    609611}
    610612static PyObject *
    611613bsddb_previous(bsddbobject *dp)
    612614{
    613         return bsddb_seq(dp, R_PREV);
     615    return bsddb_seq(dp, R_PREV);
    614616}
    615617static PyObject *
    616618bsddb_first(bsddbobject *dp)
    617619{
    618         return bsddb_seq(dp, R_FIRST);
     620    return bsddb_seq(dp, R_FIRST);
    619621}
    620622static PyObject *
    621623bsddb_last(bsddbobject *dp)
    622624{
    623         return bsddb_seq(dp, R_LAST);
     625    return bsddb_seq(dp, R_LAST);
    624626}
    625627static PyObject *
    626628bsddb_sync(bsddbobject *dp)
    627629{
    628         int status;
    629 
    630         check_bsddbobject_open(dp, NULL);
    631         BSDDB_BGN_SAVE(dp)
    632         status = (dp->di_bsddb->sync)(dp->di_bsddb, 0);
    633         BSDDB_END_SAVE(dp)
    634         if (status != 0) {
    635                 PyErr_SetFromErrno(BsddbError);
    636                 return NULL;
    637         }
    638         return PyInt_FromLong(status = 0);
     630    int status;
     631
     632    check_bsddbobject_open(dp, NULL);
     633    BSDDB_BGN_SAVE(dp)
     634    status = (dp->di_bsddb->sync)(dp->di_bsddb, 0);
     635    BSDDB_END_SAVE(dp)
     636    if (status != 0) {
     637        PyErr_SetFromErrno(BsddbError);
     638        return NULL;
     639    }
     640    return PyInt_FromLong(0);
    639641}
    640642static PyMethodDef bsddb_methods[] = {
    641         {"close",               (PyCFunction)bsddb_close, METH_NOARGS},
    642         {"keys",                (PyCFunction)bsddb_keys, METH_NOARGS},
    643         {"has_key",             (PyCFunction)bsddb_has_key, METH_VARARGS},
    644         {"set_location",        (PyCFunction)bsddb_set_location, METH_VARARGS},
    645         {"next",                (PyCFunction)bsddb_next, METH_NOARGS},
    646         {"previous",    (PyCFunction)bsddb_previous, METH_NOARGS},
    647         {"first",               (PyCFunction)bsddb_first, METH_NOARGS},
    648         {"last",                (PyCFunction)bsddb_last, METH_NOARGS},
    649         {"sync",                (PyCFunction)bsddb_sync, METH_NOARGS},
    650         {NULL,          NULL}           /* sentinel */
     643    {"close",                   (PyCFunction)bsddb_close, METH_NOARGS},
     644    {"keys",                    (PyCFunction)bsddb_keys, METH_NOARGS},
     645    {"has_key",                 (PyCFunction)bsddb_has_key, METH_VARARGS},
     646    {"set_location",            (PyCFunction)bsddb_set_location, METH_VARARGS},
     647    {"next",                    (PyCFunction)bsddb_next, METH_NOARGS},
     648    {"previous",        (PyCFunction)bsddb_previous, METH_NOARGS},
     649    {"first",                   (PyCFunction)bsddb_first, METH_NOARGS},
     650    {"last",                    (PyCFunction)bsddb_last, METH_NOARGS},
     651    {"sync",                    (PyCFunction)bsddb_sync, METH_NOARGS},
     652    {NULL,              NULL}           /* sentinel */
    651653};
    652654
    … …  
    654656bsddb_getattr(PyObject *dp, char *name)
    655657{
    656         return Py_FindMethod(bsddb_methods, dp, name);
     658    return Py_FindMethod(bsddb_methods, dp, name);
    657659}
    658660
    659661static PyTypeObject Bsddbtype = {
    660         PyObject_HEAD_INIT(NULL)
    661         0,
    662         "bsddb.bsddb",
    663         sizeof(bsddbobject),
    664         0,
    665         (destructor)bsddb_dealloc, /*tp_dealloc*/
    666         0,                      /*tp_print*/
    667         (getattrfunc)bsddb_getattr, /*tp_getattr*/
    668         0,                      /*tp_setattr*/
    669         0,                      /*tp_compare*/
    670         0,                      /*tp_repr*/
    671         0,                      /*tp_as_number*/
    672         0,                      /*tp_as_sequence*/
    673         &bsddb_as_mapping,      /*tp_as_mapping*/
     662    PyObject_HEAD_INIT(NULL)
     663    0,
     664    "bsddb.bsddb",
     665    sizeof(bsddbobject),
     666    0,
     667    (destructor)bsddb_dealloc, /*tp_dealloc*/
     668    0,                          /*tp_print*/
     669    (getattrfunc)bsddb_getattr, /*tp_getattr*/
     670    0,                          /*tp_setattr*/
     671    0,                          /*tp_compare*/
     672    0,                          /*tp_repr*/
     673    0,                          /*tp_as_number*/
     674    0,                          /*tp_as_sequence*/
     675    &bsddb_as_mapping,          /*tp_as_mapping*/
    674676};
    675677
    … …  
    677679bsdhashopen(PyObject *self, PyObject *args)
    678680{
    679         char *file;
    680         char *flag = NULL;
    681         int flags = O_RDONLY;
    682         int mode = 0666;
    683         int bsize = 0;
    684         int ffactor = 0;
    685         int nelem = 0;
    686         int cachesize = 0;
    687         int hash = 0; /* XXX currently ignored */
    688         int lorder = 0;
    689 
    690         if (!PyArg_ParseTuple(args, "z|siiiiiii:hashopen",
    691                               &file, &flag, &mode,
    692                               &bsize, &ffactor, &nelem, &cachesize,
    693                               &hash, &lorder))
    694                 return NULL;
    695         if (flag != NULL) {
    696                 /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
    697                 if (flag[0] == 'r')
    698                         flags = O_RDONLY;
    699                 else if (flag[0] == 'w')
    700                         flags = O_RDWR;
    701                 else if (flag[0] == 'c')
    702                         flags = O_RDWR|O_CREAT;
    703                 else if (flag[0] == 'n')
    704                         flags = O_RDWR|O_CREAT|O_TRUNC;
    705                 else {
    706                         PyErr_SetString(BsddbError,
    707                                 "Flag should begin with 'r', 'w', 'c' or 'n'");
    708                         return NULL;
    709                 }
    710                 if (flag[1] == 'l') {
     681    char *file;
     682    char *flag = NULL;
     683    int flags = O_RDONLY;
     684    int mode = 0666;
     685    int bsize = 0;
     686    int ffactor = 0;
     687    int nelem = 0;
     688    int cachesize = 0;
     689    int hash = 0; /* XXX currently ignored */
     690    int lorder = 0;
     691
     692    if (!PyArg_ParseTuple(args, "z|siiiiiii:hashopen",
     693                          &file, &flag, &mode,
     694                          &bsize, &ffactor, &nelem, &cachesize,
     695                          &hash, &lorder))
     696        return NULL;
     697    if (flag != NULL) {
     698        /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
     699        if (flag[0] == 'r')
     700            flags = O_RDONLY;
     701        else if (flag[0] == 'w')
     702            flags = O_RDWR;
     703        else if (flag[0] == 'c')
     704            flags = O_RDWR|O_CREAT;
     705        else if (flag[0] == 'n')
     706            flags = O_RDWR|O_CREAT|O_TRUNC;
     707        else {
     708            PyErr_SetString(BsddbError,
     709                "Flag should begin with 'r', 'w', 'c' or 'n'");
     710            return NULL;
     711        }
     712        if (flag[1] == 'l') {
    711713#if defined(O_EXLOCK) && defined(O_SHLOCK)
    712                         if (flag[0] == 'r')
    713                                 flags |= O_SHLOCK;
    714                         else
    715                                 flags |= O_EXLOCK;
     714            if (flag[0] == 'r')
     715                flags |= O_SHLOCK;
     716            else
     717                flags |= O_EXLOCK;
    716718#else
    717                         PyErr_SetString(BsddbError,
    718                                      "locking not supported on this platform");
    719                         return NULL;
    720 #endif
    721                 }
    722         }
    723         return newdbhashobject(file, flags, mode,
    724                                bsize, ffactor, nelem, cachesize, hash, lorder);
     719            PyErr_SetString(BsddbError,
     720                         "locking not supported on this platform");
     721            return NULL;
     722#endif
     723        }
     724    }
     725    return newdbhashobject(file, flags, mode,
     726                           bsize, ffactor, nelem, cachesize, hash, lorder);
    725727}
    726728
    … …  
    728730bsdbtopen(PyObject *self, PyObject *args)
    729731{
    730         char *file;
    731         char *flag = NULL;
    732         int flags = O_RDONLY;
    733         int mode = 0666;
    734         int cachesize = 0;
    735         int maxkeypage = 0;
    736         int minkeypage = 0;
    737         int btflags = 0;
    738         unsigned int psize = 0;
    739         int lorder = 0;
    740 
    741         if (!PyArg_ParseTuple(args, "z|siiiiiii:btopen",
    742                               &file, &flag, &mode,
    743                               &btflags, &cachesize, &maxkeypage, &minkeypage,
    744                               &psize, &lorder))
    745                 return NULL;
    746         if (flag != NULL) {
    747                 /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
    748                 if (flag[0] == 'r')
    749                         flags = O_RDONLY;
    750                 else if (flag[0] == 'w')
    751                         flags = O_RDWR;
    752                 else if (flag[0] == 'c')
    753                         flags = O_RDWR|O_CREAT;
    754                 else if (flag[0] == 'n')
    755                         flags = O_RDWR|O_CREAT|O_TRUNC;
    756                 else {
    757                         PyErr_SetString(BsddbError,
    758                                "Flag should begin with 'r', 'w', 'c' or 'n'");
    759                         return NULL;
    760                 }
    761                 if (flag[1] == 'l') {
     732    char *file;
     733    char *flag = NULL;
     734    int flags = O_RDONLY;
     735    int mode = 0666;
     736    int cachesize = 0;
     737    int maxkeypage = 0;
     738    int minkeypage = 0;
     739    int btflags = 0;
     740    unsigned int psize = 0;
     741    int lorder = 0;
     742
     743    if (!PyArg_ParseTuple(args, "z|siiiiiii:btopen",
     744                          &file, &flag, &mode,
     745                          &btflags, &cachesize, &maxkeypage, &minkeypage,
     746                          &psize, &lorder))
     747        return NULL;
     748    if (flag != NULL) {
     749        /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
     750        if (flag[0] == 'r')
     751            flags = O_RDONLY;
     752        else if (flag[0] == 'w')
     753            flags = O_RDWR;
     754        else if (flag[0] == 'c')
     755            flags = O_RDWR|O_CREAT;
     756        else if (flag[0] == 'n')
     757            flags = O_RDWR|O_CREAT|O_TRUNC;
     758        else {
     759            PyErr_SetString(BsddbError,
     760                   "Flag should begin with 'r', 'w', 'c' or 'n'");
     761            return NULL;
     762        }
     763        if (flag[1] == 'l') {
    762764#if defined(O_EXLOCK) && defined(O_SHLOCK)
    763                         if (flag[0] == 'r')
    764                                 flags |= O_SHLOCK;
    765                         else
    766                                 flags |= O_EXLOCK;
     765            if (flag[0] == 'r')
     766                flags |= O_SHLOCK;
     767            else
     768                flags |= O_EXLOCK;
    767769#else
    768                         PyErr_SetString(BsddbError,
    769                                     "locking not supported on this platform");
    770                         return NULL;
    771 #endif
    772                 }
    773         }
    774         return newdbbtobject(file, flags, mode,
    775                              btflags, cachesize, maxkeypage, minkeypage,
    776                              psize, lorder);
     770            PyErr_SetString(BsddbError,
     771                        "locking not supported on this platform");
     772            return NULL;
     773#endif
     774        }
     775    }
     776    return newdbbtobject(file, flags, mode,
     777                         btflags, cachesize, maxkeypage, minkeypage,
     778                         psize, lorder);
    777779}
    778780
    … …  
    780782bsdrnopen(PyObject *self, PyObject *args)
    781783{
    782         char *file;
    783         char *flag = NULL;
    784         int flags = O_RDONLY;
    785         int mode = 0666;
    786         int cachesize = 0;
    787         int rnflags = 0;
    788         unsigned int psize = 0;
    789         int lorder = 0;
    790         size_t reclen = 0;
    791         char  *bval = "";
    792         char *bfname = NULL;
    793 
    794         if (!PyArg_ParseTuple(args, "z|siiiiiiss:rnopen",
    795                               &file, &flag, &mode,
    796                               &rnflags, &cachesize, &psize, &lorder,
    797                               &reclen, &bval, &bfname))
    798                 return NULL;
    799 
    800         if (flag != NULL) {
    801                 /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
    802                 if (flag[0] == 'r')
    803                         flags = O_RDONLY;
    804                 else if (flag[0] == 'w')
    805                         flags = O_RDWR;
    806                 else if (flag[0] == 'c')
    807                         flags = O_RDWR|O_CREAT;
    808                 else if (flag[0] == 'n')
    809                         flags = O_RDWR|O_CREAT|O_TRUNC;
    810                 else {
    811                         PyErr_SetString(BsddbError,
    812                                "Flag should begin with 'r', 'w', 'c' or 'n'");
    813                         return NULL;
    814                 }
    815                 if (flag[1] == 'l') {
     784    char *file;
     785    char *flag = NULL;
     786    int flags = O_RDONLY;
     787    int mode = 0666;
     788    int cachesize = 0;
     789    int rnflags = 0;
     790    unsigned int psize = 0;
     791    int lorder = 0;
     792    size_t reclen = 0;
     793    char  *bval = "";
     794    char *bfname = NULL;
     795
     796    if (!PyArg_ParseTuple(args, "z|siiiiiiss:rnopen",
     797                          &file, &flag, &mode,
     798                          &rnflags, &cachesize, &psize, &lorder,
     799                          &reclen, &bval, &bfname))
     800        return NULL;
     801
     802    if (flag != NULL) {
     803        /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
     804        if (flag[0] == 'r')
     805            flags = O_RDONLY;
     806        else if (flag[0] == 'w')
     807            flags = O_RDWR;
     808        else if (flag[0] == 'c')
     809            flags = O_RDWR|O_CREAT;
     810        else if (flag[0] == 'n')
     811            flags = O_RDWR|O_CREAT|O_TRUNC;
     812        else {
     813            PyErr_SetString(BsddbError,
     814                   "Flag should begin with 'r', 'w', 'c' or 'n'");
     815            return NULL;
     816        }
     817        if (flag[1] == 'l') {
    816818#if defined(O_EXLOCK) && defined(O_SHLOCK)
    817                         if (flag[0] == 'r')
    818                                 flags |= O_SHLOCK;
    819                         else
    820                                 flags |= O_EXLOCK;
     819            if (flag[0] == 'r')
     820                flags |= O_SHLOCK;
     821            else
     822                flags |= O_EXLOCK;
    821823#else
    822                         PyErr_SetString(BsddbError,
    823                                     "locking not supported on this platform");
    824                         return NULL;
    825 #endif
    826                 }
    827                 else if (flag[1] != '\0') {
    828                         PyErr_SetString(BsddbError,
    829                                        "Flag char 2 should be 'l' or absent");
    830                         return NULL;
    831                 }
    832         }
    833         return newdbrnobject(file, flags, mode, rnflags, cachesize,
    834                              psize, lorder, reclen, bval[0], bfname);
     824            PyErr_SetString(BsddbError,
     825                        "locking not supported on this platform");
     826            return NULL;
     827#endif
     828        }
     829        else if (flag[1] != '\0') {
     830            PyErr_SetString(BsddbError,
     831                           "Flag char 2 should be 'l' or absent");
     832            return NULL;
     833        }
     834    }
     835    return newdbrnobject(file, flags, mode, rnflags, cachesize,
     836                         psize, lorder, reclen, bval[0], bfname);
    835837}
    836838
    837839static PyMethodDef bsddbmodule_methods[] = {
    838         {"hashopen",    (PyCFunction)bsdhashopen, METH_VARARGS},
    839         {"btopen",      (PyCFunction)bsdbtopen, METH_VARARGS},
    840         {"rnopen",      (PyCFunction)bsdrnopen, METH_VARARGS},
    841         /* strictly for use by dbhhash!!! */
    842         {"open",        (PyCFunction)bsdhashopen, METH_VARARGS},
    843         {0,             0},
     840    {"hashopen",        (PyCFunction)bsdhashopen, METH_VARARGS},
     841    {"btopen",          (PyCFunction)bsdbtopen, METH_VARARGS},
     842    {"rnopen",          (PyCFunction)bsdrnopen, METH_VARARGS},
     843    /* strictly for use by dbhhash!!! */
     844    {"open",            (PyCFunction)bsdhashopen, METH_VARARGS},
     845    {0,                 0},
    844846};
    845847
    846848PyMODINIT_FUNC
    847849initbsddb185(void) {
    848         PyObject *m, *d;
     850    PyObject *m, *d;
    849851
    850852    if (PyErr_WarnPy3k("the bsddb185 module has been removed in "
    851853                       "Python 3.0", 2) < 0)
    852         return;   
    853 
    854         Bsddbtype.ob_type = &PyType_Type;
    855         m = Py_InitModule("bsddb185", bsddbmodule_methods);
    856         if (m == NULL)
    857                 return;
    858         d = PyModule_GetDict(m);
    859         BsddbError = PyErr_NewException("bsddb.error", NULL, NULL);
    860         if (BsddbError != NULL)
    861                 PyDict_SetItemString(d, "error", BsddbError);
    862 }
     854    return;
     855
     856    Bsddbtype.ob_type = &PyType_Type;
     857    m = Py_InitModule("bsddb185", bsddbmodule_methods);
     858    if (m == NULL)
     859        return;
     860    d = PyModule_GetDict(m);
     861    BsddbError = PyErr_NewException("bsddb.error", NULL, NULL);
     862    if (BsddbError != NULL)
     863        PyDict_SetItemString(d, "error", BsddbError);
     864}
Note: See TracChangeset for help on using the changeset viewer.