Left: | ||
Right: |
LEFT | RIGHT |
---|---|
1 | 1 |
2 /* DBM module using dictionary interface */ | 2 /* DBM module using dictionary interface */ |
3 /* Author: Anthony Baxter, after dbmmodule.c */ | 3 /* Author: Anthony Baxter, after dbmmodule.c */ |
4 /* Doc strings: Mitch Chapman */ | 4 /* Doc strings: Mitch Chapman */ |
5 | 5 |
6 | 6 |
7 #include "Python.h" | 7 #include "Python.h" |
8 | 8 |
9 #include <sys/types.h> | 9 #include <sys/types.h> |
10 #include <sys/stat.h> | 10 #include <sys/stat.h> |
(...skipping 17 matching lines...) Expand all Loading... | |
28 keys and values, and the items() and values() methods are not\n\ | 28 keys and values, and the items() and values() methods are not\n\ |
29 supported."); | 29 supported."); |
30 | 30 |
31 typedef struct { | 31 typedef struct { |
32 PyObject_HEAD | 32 PyObject_HEAD |
33 int di_size; /* -1 means recompute */ | 33 int di_size; /* -1 means recompute */ |
34 GDBM_FILE di_dbm; | 34 GDBM_FILE di_dbm; |
35 } dbmobject; | 35 } dbmobject; |
36 | 36 |
37 static PyTypeObject Dbmtype; | 37 static PyTypeObject Dbmtype; |
38 PyTypeObject PyDbmKeys_Type; | 38 PyTypeObject DbmKeys_Type; |
39 PyTypeObject PyDbmValues_Type; | 39 PyTypeObject DbmValues_Type; |
40 PyTypeObject PyDbmItems_Type; | 40 PyTypeObject DbmItems_Type; |
41 | 41 |
42 #define is_dbmobject(v) (Py_TYPE(v) == &Dbmtype) | 42 #define is_dbmobject(v) (Py_TYPE(v) == &Dbmtype) |
43 #define check_dbmobject_open(v) if ((v)->di_dbm == NULL) \ | 43 #define check_dbmobject_open(v) if ((v)->di_dbm == NULL) \ |
44 { PyErr_SetString(DbmError, "GDBM object has already been closed"); \ | 44 { PyErr_SetString(DbmError, "GDBM object has already been closed"); \ |
45 return NULL; } | 45 return NULL; } |
46 #define is_dbmkeysobject(op) PyObject_TypeCheck(op, &PyDbmKeys_Type) | 46 #define is_dbmkeysobject(op) PyObject_TypeCheck(op, &DbmKeys_Type) |
47 #define is_dbmitemsobject(op) PyObject_TypeCheck(op, &PyDbmItems_Type) | 47 #define is_dbmitemsobject(op) PyObject_TypeCheck(op, &DbmItems_Type) |
48 #define is_dbmviewsetobject(op) \ | 48 #define is_dbmviewsetobject(op) \ |
49 (is_dbmkeysobject(op) || is_dbmitemsobject(op)) | 49 (is_dbmkeysobject(op) || is_dbmitemsobject(op)) |
50 | |
51 | |
50 | 52 |
51 static PyObject *DbmError; | 53 static PyObject *DbmError; |
52 | 54 |
53 PyDoc_STRVAR(gdbm_object__doc__, | 55 PyDoc_STRVAR(gdbm_object__doc__, |
54 "This object represents a GDBM database.\n\ | 56 "This object represents a GDBM database.\n\ |
55 GDBM objects behave like mappings (dictionaries), except that keys and\n\ | 57 GDBM objects behave like mappings (dictionaries), except that keys and\n\ |
56 values are always strings. Printing a GDBM object doesn't print the\n\ | 58 values are always strings. Printing a GDBM object doesn't print the\n\ |
57 keys and values, and the items() and values() methods are not\n\ | 59 keys and values, and the items() and values() methods are not\n\ |
58 supported.\n\ | 60 supported.\n\ |
59 \n\ | 61 \n\ |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
245 Py_INCREF(Py_None); | 247 Py_INCREF(Py_None); |
246 return Py_None; | 248 return Py_None; |
247 } | 249 } |
248 | 250 |
249 static int | 251 static int |
250 dbm_contains(PyObject *self, PyObject *arg) | 252 dbm_contains(PyObject *self, PyObject *arg) |
251 { | 253 { |
252 dbmobject *dp = (dbmobject *)self; | 254 dbmobject *dp = (dbmobject *)self; |
253 datum key; | 255 datum key; |
254 | 256 |
255 if (!PyArg_Parse(arg, "s#", &key.dptr, &key.dsize)) | |
256 return -1; | |
257 | |
258 if ((dp)->di_dbm == NULL) { | 257 if ((dp)->di_dbm == NULL) { |
259 PyErr_SetString(DbmError, | 258 PyErr_SetString(DbmError, |
260 "GDBM object has already been closed"); | 259 "GDBM object has already been closed"); |
261 return -1; | 260 return -1; |
262 } | 261 } |
262 | |
263 if (!PyArg_Parse(arg, "s#", &key.dptr, &key.dsize)) | |
264 return -1; | |
265 | |
263 return gdbm_exists(dp->di_dbm, key); | 266 return gdbm_exists(dp->di_dbm, key); |
264 } | 267 } |
265 | 268 |
266 static PySequenceMethods dbm_as_sequence = { | 269 static PySequenceMethods dbm_as_sequence = { |
267 0, /* sq_length */ | 270 0, /* sq_length */ |
268 0, /* sq_concat */ | 271 0, /* sq_concat */ |
269 0, /* sq_repeat */ | 272 0, /* sq_repeat */ |
270 0, /* sq_item */ | 273 0, /* sq_item */ |
271 0, /* sq_slice */ | 274 0, /* sq_slice */ |
272 0, /* sq_ass_item */ | 275 0, /* sq_ass_item */ |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
378 otherwise return default if specified, raise KeyError if not specified."); | 381 otherwise return default if specified, raise KeyError if not specified."); |
379 | 382 |
380 static PyObject * | 383 static PyObject * |
381 dbm_pop(dbmobject *dp, PyObject *args) | 384 dbm_pop(dbmobject *dp, PyObject *args) |
382 { | 385 { |
383 datum key, val; | 386 datum key, val; |
384 PyObject *defvalue = Py_None, *result; | 387 PyObject *defvalue = Py_None, *result; |
385 char *tmp_ptr; | 388 char *tmp_ptr; |
386 Py_ssize_t tmp_size; | 389 Py_ssize_t tmp_size; |
387 | 390 |
391 check_dbmobject_open(dp); | |
392 | |
388 if (!PyArg_ParseTuple(args, "s#|O:get", &tmp_ptr, &tmp_size, &defvalue)) | 393 if (!PyArg_ParseTuple(args, "s#|O:get", &tmp_ptr, &tmp_size, &defvalue)) |
389 return NULL; | 394 return NULL; |
390 | 395 |
391 key.dptr = tmp_ptr; | 396 key.dptr = tmp_ptr; |
392 key.dsize = tmp_size; | 397 key.dsize = tmp_size; |
393 check_dbmobject_open(dp); | |
394 val = gdbm_fetch(dp->di_dbm, key); | 398 val = gdbm_fetch(dp->di_dbm, key); |
395 if (val.dptr != NULL) { | 399 if (val.dptr != NULL) { |
396 result = PyBytes_FromStringAndSize(val.dptr, val.dsize); | 400 result = PyBytes_FromStringAndSize(val.dptr, val.dsize); |
397 free(val.dptr); | 401 free(val.dptr); |
398 if (result == NULL) | 402 if (result == NULL) |
399 return NULL; | 403 return NULL; |
400 if (gdbm_delete(dp->di_dbm, key) < 0) { | 404 if (gdbm_delete(dp->di_dbm, key) < 0) { |
401 PyErr_SetString(PyExc_ValueError, "Delete key error"); | 405 PyErr_SetString(PyExc_KeyError, "Delete key error"); |
402 Py_DECREF(result); | 406 Py_DECREF(result); |
403 return NULL; | 407 return NULL; |
404 } | 408 } |
405 dp->di_size = -1; | 409 dp->di_size = -1; |
406 return result; | 410 return result; |
407 } | 411 } |
408 else { | 412 else { |
409 Py_INCREF(defvalue); | 413 Py_INCREF(defvalue); |
410 return defvalue; | 414 return defvalue; |
411 } | 415 } |
412 } | 416 } |
413 | 417 |
414 PyDoc_STRVAR(dbm_popitem__doc__, | 418 PyDoc_STRVAR(dbm_popitem__doc__, |
415 "popitem() -> (key, value)\n\ | 419 "popitem() -> (key, value)\n\ |
416 Return the next (key, value) tuple if there is items in db, \n\ | 420 Return the next (key, value) tuple if there is items in db, \n\ |
417 otherwise raise KeyError."); | 421 otherwise raise KeyError."); |
418 | 422 |
419 static PyObject * | 423 static PyObject * |
420 dbm_popitem(dbmobject *dp, PyObject *unused) | 424 dbm_popitem(dbmobject *dp, PyObject *unused) |
421 { | 425 { |
422 datum k, v; | 426 datum k, v; |
423 PyObject *result, *iter, *key, *val; | 427 PyObject *result, *iter, *key, *val; |
424 iter = PyObject_GetIter((PyObject *)dp); | 428 iter = PyObject_GetIter((PyObject *)dp); |
425 if (iter == NULL) | 429 if (iter == NULL) |
426 return NULL; | 430 return NULL; |
427 key = PyIter_Next(iter); | 431 key = PyIter_Next(iter); |
428 Py_DECREF(iter); | 432 Py_DECREF(iter); |
429 if (key == NULL) { | 433 if (key == NULL) { |
430 if (!PyErr_Occurred()) | 434 if (!PyErr_Occurred()) |
431 PyErr_SetString(PyExc_KeyError, "GDBM object has no more items"); | 435 PyErr_SetString(PyExc_KeyError, "GDBM object has no more items"); |
merwok
2011/02/12 20:14:50
Why caps all of a sudden?
ray
2011/02/16 14:44:14
Sorry, I didn't understand this sentence. I know n
merwok
2011/02/16 16:34:05
Caps means capitalized letters, here “GDBM” instea
| |
432 return NULL; | 436 return NULL; |
433 } | 437 } |
434 assert(PyBytes_Check(key)); | 438 assert(PyBytes_Check(key)); |
435 if (PyBytes_AsStringAndSize(key, &k.dptr, &k.dsize)) | 439 if (PyBytes_AsStringAndSize(key, &k.dptr, &k.dsize)) |
436 goto fail1; | 440 goto fail; |
437 v = gdbm_fetch(dp->di_dbm, k); | 441 v = gdbm_fetch(dp->di_dbm, k); |
438 assert(v.dptr != NULL); | 442 if (v.dptr == NULL) |
merwok
2011/02/16 16:34:05
I don’t know how asserts work in C. I know that I
ray
2011/02/17 15:04:45
It work in a similar way in C. By defining the mac
merwok
2011/02/17 23:31:03
Okay. In Python code, I always avoid asserts, bec
ray
2011/02/18 13:09:26
In a normal python build, the NDEBUG macro will be
| |
443 goto fail; | |
439 val = PyBytes_FromStringAndSize(v.dptr, v.dsize); | 444 val = PyBytes_FromStringAndSize(v.dptr, v.dsize); |
440 free(v.dptr); | 445 free(v.dptr); |
441 if (val == NULL) | 446 if (val == NULL) |
442 goto fail1; | 447 goto fail; |
443 result = PyTuple_New(2); | 448 result = PyTuple_New(2); |
444 if (result == NULL) | 449 if (result == NULL) { |
445 goto fail2; | 450 Py_DECREF(val); |
451 goto fail; | |
452 } | |
446 if (PyTuple_SetItem(result, 0, key)) { | 453 if (PyTuple_SetItem(result, 0, key)) { |
447 Py_DECREF(val); | 454 Py_DECREF(val); |
448 Py_DECREF(result); | 455 Py_DECREF(result); |
449 return NULL; | 456 return NULL; |
450 } | 457 } |
451 if (PyTuple_SetItem(result, 1, val)) { | 458 if (PyTuple_SetItem(result, 1, val)) { |
452 Py_DECREF(result); | 459 Py_DECREF(result); |
453 return NULL; | 460 return NULL; |
454 } | 461 } |
455 if (gdbm_delete(dp->di_dbm, k) < 0) { | 462 if (gdbm_delete(dp->di_dbm, k) < 0) { |
456 PyErr_SetString(PyExc_ValueError, "Delete key error"); | 463 PyErr_SetString(PyExc_KeyError, "Delete key error"); |
457 Py_DECREF(result); | 464 Py_DECREF(result); |
458 return NULL; | 465 return NULL; |
459 } | 466 } |
467 dp->di_size = -1; | |
460 return result; | 468 return result; |
461 fail1: | 469 fail: |
462 Py_DECREF(val); | |
463 fail2: | |
464 Py_DECREF(key); | 470 Py_DECREF(key); |
465 return NULL; | 471 return NULL; |
466 } | 472 } |
467 | 473 |
468 PyDoc_STRVAR(dbm_clear__doc__, | 474 PyDoc_STRVAR(dbm_clear__doc__, |
469 "clear() -> None\n\ | 475 "clear() -> None\n\ |
470 Delete all the items in db."); | 476 Delete all the items in db."); |
471 | 477 |
472 static PyObject * | 478 static PyObject * |
473 dbm_clear(dbmobject *dp, PyObject *unused) | 479 dbm_clear(dbmobject *dp, PyObject *unused) |
474 { | 480 { |
475 datum key; | 481 datum key; |
476 | 482 |
477 if (dp == NULL || !is_dbmobject(dp)) { | 483 if (dp == NULL || !is_dbmobject(dp)) { |
478 PyErr_BadInternalCall(); | 484 PyErr_BadInternalCall(); |
479 return NULL; | 485 return NULL; |
480 } | 486 } |
481 check_dbmobject_open(dp); | 487 check_dbmobject_open(dp); |
482 | 488 |
483 key = gdbm_firstkey(dp->di_dbm); | 489 key = gdbm_firstkey(dp->di_dbm); |
484 while (key.dptr) { | 490 while (key.dptr) { |
485 if (gdbm_delete(dp->di_dbm, key) < 0) { | 491 if (gdbm_delete(dp->di_dbm, key) < 0) { |
486 PyErr_SetString(PyExc_ValueError, "Delete key error"); | 492 PyErr_SetString(PyExc_KeyError, "Delete key error"); |
487 free(key.dptr); | 493 free(key.dptr); |
488 return NULL; | 494 return NULL; |
489 } | 495 } |
490 free(key.dptr); | 496 free(key.dptr); |
491 key = gdbm_firstkey(dp->di_dbm); | 497 key = gdbm_firstkey(dp->di_dbm); |
492 } | 498 } |
493 Py_RETURN_NONE; | 499 Py_RETURN_NONE; |
494 } | 500 } |
495 | 501 |
496 static PyObject * | 502 static PyObject * |
497 dbm_update(dbmobject *dp, PyObject *args, PyObject *kwds) | 503 dbm_update(dbmobject *dp, PyObject *args, PyObject *kwds) |
498 { | 504 { |
499 datum krec, drec; | 505 datum krec, drec; |
500 PyObject *arg = NULL; | 506 PyObject *arg = NULL; |
501 PyObject *coll_mod, *mapping_abc; | 507 PyObject *coll_mod, *mapping_abc; |
502 PyObject *arg_iter, *arg_keys, *iter_item, *item_value; | 508 PyObject *arg_iter, *arg_keys, *iter_item, *item_value; |
503 PyObject *key, *value; | 509 PyObject *key, *value; |
504 Py_ssize_t pos = 0; | 510 Py_ssize_t pos = 0; |
505 | 511 |
506 if (dp == NULL || !is_dbmobject(dp)) { | 512 if (dp == NULL || !is_dbmobject(dp)) { |
507 PyErr_BadInternalCall(); | 513 PyErr_BadInternalCall(); |
508 return NULL; | 514 return NULL; |
509 } | 515 } |
510 check_dbmobject_open(dp); | 516 check_dbmobject_open(dp); |
511 | 517 |
512 if ((coll_mod = PyImport_ImportModule("collections")) == NULL) | 518 if ((coll_mod = PyImport_ImportModule("collections")) == NULL) |
513 return NULL; | 519 return NULL; |
514 if ((mapping_abc = PyObject_GetAttrString(coll_mod, "Mapping")) == | 520 if ((mapping_abc = PyObject_GetAttrString(coll_mod, |
515 NULL) { | 521 "Mapping")) == NULL) { |
516 Py_DECREF(coll_mod); | 522 Py_DECREF(coll_mod); |
517 return NULL; | 523 return NULL; |
518 } | 524 } |
519 Py_DECREF(coll_mod); | 525 Py_DECREF(coll_mod); |
520 | 526 |
521 if (!PyArg_UnpackTuple(args, "update", 0, 1, &arg)) | 527 if (!PyArg_UnpackTuple(args, "update", 0, 1, &arg)) |
522 Py_DECREF(mapping_abc); | 528 Py_DECREF(mapping_abc); |
523 else if (arg != NULL) { | 529 else if (arg != NULL) { |
524 if (PyObject_IsInstance(arg, mapping_abc)) { | 530 if (PyObject_IsInstance(arg, mapping_abc)) { |
525 Py_DECREF(mapping_abc); | 531 Py_DECREF(mapping_abc); |
(...skipping 150 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
676 PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno)); | 682 PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno)); |
677 PyErr_SetString(DbmError, "Cannot add item to database"); | 683 PyErr_SetString(DbmError, "Cannot add item to database"); |
678 return NULL; | 684 return NULL; |
679 } | 685 } |
680 } | 686 } |
681 Py_RETURN_NONE; | 687 Py_RETURN_NONE; |
682 } | 688 } |
683 | 689 |
684 PyDoc_STRVAR(dbm_update__doc__, | 690 PyDoc_STRVAR(dbm_update__doc__, |
685 "update([other][, **keywords]) -> None\n\ | 691 "update([other][, **keywords]) -> None\n\ |
686 Add all the items in other if other is a mapping object, raise TypeError " | 692 Add all the items in keywords to the databases.\n\ |
687 "else, as well as those in keywords."); | 693 If other is a mapping object, does: for k in other: self[k] = other[k]\n\ |
merwok
2011/02/16 16:34:05
The phrasing is a bit awkward.
ray
2011/02/17 15:04:45
How about this:
"""
Add all the items in keywords
merwok
2011/02/17 23:31:03
Yes, following the doc for dict.update is easier.
ray
2011/02/18 13:09:26
Yes, update() is implemented follow the MutableMap
| |
694 Else if other has a \"keys()\" method, does: for k in other.keys(): \ | |
695 self[k] = other[k]\n\ | |
696 Else does: for k, v in other: self[k] = v"); | |
688 | 697 |
689 typedef struct { | 698 typedef struct { |
690 PyObject_HEAD | 699 PyObject_HEAD |
691 dbmobject *dbm; /* Set to NULL when iterator is exhausted */ | 700 dbmobject *dbm; /* Set to NULL when iterator is exhausted */ |
692 datum curr_key; | 701 datum curr_key; |
693 } dbmiterobject; | 702 } dbmiterobject; |
694 | 703 |
695 static void | 704 static void |
696 dbmiter_dealloc(dbmiterobject *di) | 705 dbmiter_dealloc(dbmiterobject *di) |
697 { | 706 { |
(...skipping 11 matching lines...) Expand all Loading... | |
709 if (di->dbm != NULL) { | 718 if (di->dbm != NULL) { |
710 if (di->curr_key.dptr == NULL) | 719 if (di->curr_key.dptr == NULL) |
711 di->curr_key = gdbm_firstkey(di->dbm->di_dbm); | 720 di->curr_key = gdbm_firstkey(di->dbm->di_dbm); |
712 else { | 721 else { |
713 next = gdbm_nextkey(di->dbm->di_dbm, di->curr_key); | 722 next = gdbm_nextkey(di->dbm->di_dbm, di->curr_key); |
714 free(di->curr_key.dptr); | 723 free(di->curr_key.dptr); |
715 di->curr_key = next; | 724 di->curr_key = next; |
716 } | 725 } |
717 if (di->curr_key.dptr == NULL) { | 726 if (di->curr_key.dptr == NULL) { |
718 PyErr_SetNone(PyExc_StopIteration); | 727 PyErr_SetNone(PyExc_StopIteration); |
728 Py_DECREF(di->dbm); | |
719 di->dbm = NULL; | 729 di->dbm = NULL; |
720 return NULL; | 730 return NULL; |
721 } | 731 } |
722 result = PyBytes_FromStringAndSize(di->curr_key.dptr, | 732 result = PyBytes_FromStringAndSize(di->curr_key.dptr, |
723 di->curr_key.dsize); | 733 di->curr_key.dsize); |
724 return result; | 734 return result; |
725 } | 735 } |
726 else { | 736 else { |
727 //the iteration has already exhaust. | 737 //the iteration has already exhaust. |
728 PyErr_SetNone(PyExc_StopIteration); | 738 PyErr_SetNone(PyExc_StopIteration); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
771 if (di->dbm != NULL) { | 781 if (di->dbm != NULL) { |
772 if (di->curr_key.dptr == NULL) | 782 if (di->curr_key.dptr == NULL) |
773 di->curr_key = gdbm_firstkey(di->dbm->di_dbm); | 783 di->curr_key = gdbm_firstkey(di->dbm->di_dbm); |
774 else { | 784 else { |
775 next = gdbm_nextkey(di->dbm->di_dbm, di->curr_key); | 785 next = gdbm_nextkey(di->dbm->di_dbm, di->curr_key); |
776 free(di->curr_key.dptr); | 786 free(di->curr_key.dptr); |
777 di->curr_key = next; | 787 di->curr_key = next; |
778 } | 788 } |
779 if (di->curr_key.dptr == NULL) { | 789 if (di->curr_key.dptr == NULL) { |
780 PyErr_SetNone(PyExc_StopIteration); | 790 PyErr_SetNone(PyExc_StopIteration); |
791 Py_DECREF(di->dbm); | |
781 di->dbm = NULL; | 792 di->dbm = NULL; |
782 return NULL; | 793 return NULL; |
783 } | 794 } |
784 result_key = PyBytes_FromStringAndSize(di->curr_key.dptr, | 795 result_key = PyBytes_FromStringAndSize(di->curr_key.dptr, |
785 di->curr_key.dsize); | 796 di->curr_key.dsize); |
786 if (result_key == NULL) | 797 if (result_key == NULL) |
787 return NULL; | 798 return NULL; |
788 result_data = gdbm_fetch(di->dbm->di_dbm, di->curr_key); | 799 result_data = gdbm_fetch(di->dbm->di_dbm, di->curr_key); |
789 if (result_data.dptr == 0) { | 800 if (result_data.dptr == 0) { |
790 PyErr_SetObject(PyExc_KeyError, result_key); | 801 PyErr_SetObject(PyExc_KeyError, result_key); |
791 Py_DECREF(result_key); | 802 Py_DECREF(result_key); |
792 return NULL; | 803 return NULL; |
793 } | 804 } |
805 Py_DECREF(result_key); | |
794 result_value = PyBytes_FromStringAndSize(result_data.dptr, | 806 result_value = PyBytes_FromStringAndSize(result_data.dptr, |
795 result_data.dsize); | 807 result_data.dsize); |
808 free(result_data.dptr); | |
796 return result_value; | 809 return result_value; |
797 } | 810 } |
798 else { | 811 else { |
799 //the iteration has already exhaust. | 812 //the iteration has already exhaust. |
800 PyErr_SetNone(PyExc_StopIteration); | 813 PyErr_SetNone(PyExc_StopIteration); |
801 return NULL; | 814 return NULL; |
802 } | 815 } |
803 } | 816 } |
804 | 817 |
805 PyTypeObject DbmIterValue_Type= { | 818 PyTypeObject DbmIterValue_Type= { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
844 if (di->dbm != NULL) { | 857 if (di->dbm != NULL) { |
845 if (di->curr_key.dptr == NULL) | 858 if (di->curr_key.dptr == NULL) |
846 di->curr_key = gdbm_firstkey(di->dbm->di_dbm); | 859 di->curr_key = gdbm_firstkey(di->dbm->di_dbm); |
847 else { | 860 else { |
848 next = gdbm_nextkey(di->dbm->di_dbm, di->curr_key); | 861 next = gdbm_nextkey(di->dbm->di_dbm, di->curr_key); |
849 free(di->curr_key.dptr); | 862 free(di->curr_key.dptr); |
850 di->curr_key = next; | 863 di->curr_key = next; |
851 } | 864 } |
852 if (di->curr_key.dptr == NULL) { | 865 if (di->curr_key.dptr == NULL) { |
853 PyErr_SetNone(PyExc_StopIteration); | 866 PyErr_SetNone(PyExc_StopIteration); |
867 Py_DECREF(di->dbm); | |
854 di->dbm = NULL; | 868 di->dbm = NULL; |
855 return NULL; | 869 return NULL; |
856 } | 870 } |
857 result_key = PyBytes_FromStringAndSize(di->curr_key.dptr, | 871 result_key = PyBytes_FromStringAndSize(di->curr_key.dptr, |
858 di->curr_key.dsize); | 872 di->curr_key.dsize); |
859 if (result_key == NULL) | 873 if (result_key == NULL) |
860 return NULL; | 874 return NULL; |
861 result_data = gdbm_fetch(di->dbm->di_dbm, di->curr_key); | 875 result_data = gdbm_fetch(di->dbm->di_dbm, di->curr_key); |
862 if (result_data.dptr == 0) { | 876 if (result_data.dptr == 0) { |
863 PyErr_SetObject(PyExc_KeyError, result_key); | 877 PyErr_SetObject(PyExc_KeyError, result_key); |
864 Py_DECREF(result_key); | 878 Py_DECREF(result_key); |
865 return NULL; | 879 return NULL; |
866 } | 880 } |
867 result_value = PyBytes_FromStringAndSize(result_data.dptr, | 881 result_value = PyBytes_FromStringAndSize(result_data.dptr, |
868 result_data.dsize); | 882 result_data.dsize); |
883 free(result_data.dptr); | |
869 if (result_value == NULL) { | 884 if (result_value == NULL) { |
870 Py_DECREF(result_key); | 885 Py_DECREF(result_key); |
871 return NULL; | 886 return NULL; |
872 } | 887 } |
873 result = PyTuple_New(2); | 888 result = PyTuple_New(2); |
874 if (result == NULL) { | 889 if (result == NULL) { |
875 Py_DECREF(result_key); | 890 Py_DECREF(result_key); |
876 Py_DECREF(result_value); | 891 Py_DECREF(result_value); |
877 return NULL; | 892 return NULL; |
878 } | 893 } |
879 if (PyTuple_SetItem(result, 0, result_key)) { | 894 if (PyTuple_SetItem(result, 0, result_key)) { |
880 Py_DECREF(result); | 895 Py_DECREF(result); |
881 Py_DECREF(result_value); | 896 Py_DECREF(result_value); |
882 return NULL; | 897 return NULL; |
883 } | 898 } |
884 if (PyTuple_SetItem(result, 1, result_value)) { | 899 if (PyTuple_SetItem(result, 1, result_value)) { |
885 Py_DECREF(result); | 900 Py_DECREF(result); |
886 return NULL; | 901 return NULL; |
887 } | 902 } |
888 return result; | 903 return result; |
889 } | 904 } |
890 else { | 905 else { |
891 //the iteration has already exhaust. | 906 //the iteration has already exhaust. |
892 PyErr_SetNone(PyExc_StopIteration); | 907 PyErr_SetNone(PyExc_StopIteration); |
893 return NULL; | 908 return NULL; |
894 } | 909 } |
895 } | 910 } |
896 | 911 |
897 PyTypeObject DbmIterItem_Type= { | 912 PyTypeObject DbmIterItem_Type = { |
898 PyVarObject_HEAD_INIT(&PyType_Type, 0) | 913 PyVarObject_HEAD_INIT(&PyType_Type, 0) |
899 "DbmIterItem_Type", /* tp_name */ | 914 "DbmIterItem_Type", /* tp_name */ |
900 sizeof(dbmiterobject), /* tp_basicsize */ | 915 sizeof(dbmiterobject), /* tp_basicsize */ |
901 0, /* tp_itemsize */ | 916 0, /* tp_itemsize */ |
902 /* methods */ | 917 /* methods */ |
903 (destructor)dbmiter_dealloc, /* tp_dealloc */ | 918 (destructor)dbmiter_dealloc, /* tp_dealloc */ |
904 0, /* tp_print */ | 919 0, /* tp_print */ |
905 0, /* tp_getattr */ | 920 0, /* tp_getattr */ |
906 0, /* tp_setattr */ | 921 0, /* tp_setattr */ |
907 0, /* tp_reserved */ | 922 0, /* tp_reserved */ |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
965 | 980 |
966 static PyObject * | 981 static PyObject * |
967 dbmview_new(PyObject *dbm, PyTypeObject *type) | 982 dbmview_new(PyObject *dbm, PyTypeObject *type) |
968 { | 983 { |
969 dbmviewobject *dv; | 984 dbmviewobject *dv; |
970 if (dbm == NULL) { | 985 if (dbm == NULL) { |
971 PyErr_BadInternalCall(); | 986 PyErr_BadInternalCall(); |
972 return NULL; | 987 return NULL; |
973 } | 988 } |
974 if (!is_dbmobject(dbm)) { | 989 if (!is_dbmobject(dbm)) { |
975 /* XXX Get rid of this restriction later */ | |
976 PyErr_Format(PyExc_TypeError, | 990 PyErr_Format(PyExc_TypeError, |
977 "%s() requires a dbm argument, not '%s'", | 991 "%s() requires a dbm argument, not '%s'", |
978 type->tp_name, dbm->ob_type->tp_name); | 992 type->tp_name, dbm->ob_type->tp_name); |
979 return NULL; | 993 return NULL; |
980 } | 994 } |
981 dv = PyObject_New(dbmviewobject, type); | 995 dv = PyObject_New(dbmviewobject, type); |
982 if (dv == NULL) | 996 if (dv == NULL) |
983 return NULL; | 997 return NULL; |
984 Py_INCREF(dbm); | 998 Py_INCREF(dbm); |
985 dv->dv_dbm = (dbmobject *)dbm; | 999 dv->dv_dbm = (dbmobject *)dbm; |
(...skipping 26 matching lines...) Expand all Loading... | |
1012 return ok; | 1026 return ok; |
1013 } | 1027 } |
1014 | 1028 |
1015 static PyObject * | 1029 static PyObject * |
1016 dbmview_richcompare(PyObject *self, PyObject *other, int op) | 1030 dbmview_richcompare(PyObject *self, PyObject *other, int op) |
1017 { | 1031 { |
1018 Py_ssize_t len_self, len_other; | 1032 Py_ssize_t len_self, len_other; |
1019 int ok; | 1033 int ok; |
1020 PyObject *result; | 1034 PyObject *result; |
1021 | 1035 |
1022 assert(self != NULL); | 1036 assert(self != NULL && other != NULL); |
1023 assert(is_dbmviewsetobject(self)); | 1037 assert(is_dbmviewsetobject(self)); |
1024 assert(other != NULL); | |
1025 | 1038 |
1026 if (!PyAnySet_Check(other) && !is_dbmviewsetobject(other)) { | 1039 if (!PyAnySet_Check(other) && !is_dbmviewsetobject(other)) { |
1027 Py_INCREF(Py_NotImplemented); | 1040 Py_INCREF(Py_NotImplemented); |
1028 return Py_NotImplemented; | 1041 return Py_NotImplemented; |
1029 } | 1042 } |
1030 | 1043 |
1031 len_self = PyObject_Size(self); | 1044 len_self = PyObject_Size(self); |
1032 if (len_self < 0) | 1045 if (len_self < 0) |
1033 return NULL; | 1046 return NULL; |
1034 len_other = PyObject_Size(other); | 1047 len_other = PyObject_Size(other); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1066 ok = all_contained_in(other, self); | 1079 ok = all_contained_in(other, self); |
1067 break; | 1080 break; |
1068 | 1081 |
1069 } | 1082 } |
1070 if (ok < 0) | 1083 if (ok < 0) |
1071 return NULL; | 1084 return NULL; |
1072 result = ok ? Py_True : Py_False; | 1085 result = ok ? Py_True : Py_False; |
1073 Py_INCREF(result); | 1086 Py_INCREF(result); |
1074 return result; | 1087 return result; |
1075 } | 1088 } |
1089 | |
1090 static PyObject* | |
1091 dbmviews_sub(PyObject* self, PyObject *other) | |
1092 { | |
1093 PyObject *result = PySet_New(self); | |
1094 PyObject *tmp; | |
1095 if (result == NULL) | |
1096 return NULL; | |
1097 | |
1098 tmp = PyObject_CallMethod(result, "difference_update", "O", other); | |
1099 if (tmp == NULL) { | |
1100 Py_DECREF(result); | |
1101 return NULL; | |
1102 } | |
1103 | |
1104 Py_DECREF(tmp); | |
1105 return result; | |
1106 } | |
1107 | |
1108 static PyObject* | |
1109 dbmviews_and(PyObject* self, PyObject *other) | |
1110 { | |
1111 PyObject *result = PySet_New(self); | |
1112 PyObject *tmp; | |
1113 if (result == NULL) | |
1114 return NULL; | |
1115 | |
1116 tmp = PyObject_CallMethod(result, "intersection_update", "O", other); | |
1117 if (tmp == NULL) { | |
1118 Py_DECREF(result); | |
1119 return NULL; | |
1120 } | |
1121 | |
1122 Py_DECREF(tmp); | |
1123 return result; | |
1124 } | |
1125 | |
1126 static PyObject* | |
1127 dbmviews_or(PyObject* self, PyObject *other) | |
1128 { | |
1129 PyObject *result = PySet_New(self); | |
1130 PyObject *tmp; | |
1131 if (result == NULL) | |
1132 return NULL; | |
1133 | |
1134 tmp = PyObject_CallMethod(result, "update", "O", other); | |
1135 if (tmp == NULL) { | |
1136 Py_DECREF(result); | |
1137 return NULL; | |
1138 } | |
1139 | |
1140 Py_DECREF(tmp); | |
1141 return result; | |
1142 } | |
1143 | |
1144 static PyObject* | |
1145 dbmviews_xor(PyObject* self, PyObject *other) | |
1146 { | |
1147 PyObject *result = PySet_New(self); | |
1148 PyObject *tmp; | |
1149 if (result == NULL) | |
1150 return NULL; | |
1151 | |
1152 tmp = PyObject_CallMethod(result, "symmetric_difference_update", "O", | |
1153 other); | |
1154 if (tmp == NULL) { | |
1155 Py_DECREF(result); | |
1156 return NULL; | |
1157 } | |
1158 | |
1159 Py_DECREF(tmp); | |
1160 return result; | |
1161 } | |
1162 | |
1163 static PyNumberMethods dbmviews_as_number = { | |
1164 0, /*nb_add*/ | |
1165 (binaryfunc)dbmviews_sub, /*nb_subtract*/ | |
1166 0, /*nb_multiply*/ | |
1167 0, /*nb_remainder*/ | |
1168 0, /*nb_divmod*/ | |
1169 0, /*nb_power*/ | |
1170 0, /*nb_negative*/ | |
1171 0, /*nb_positive*/ | |
1172 0, /*nb_absolute*/ | |
1173 0, /*nb_bool*/ | |
1174 0, /*nb_invert*/ | |
1175 0, /*nb_lshift*/ | |
1176 0, /*nb_rshift*/ | |
1177 (binaryfunc)dbmviews_and, /*nb_and*/ | |
1178 (binaryfunc)dbmviews_xor, /*nb_xor*/ | |
1179 (binaryfunc)dbmviews_or, /*nb_or*/ | |
1180 }; | |
1076 | 1181 |
1077 /*** dbm_keys ***/ | 1182 /*** dbm_keys ***/ |
1078 | 1183 |
1079 static PyObject * | 1184 static PyObject * |
1080 dbmkeys_iter(dbmviewobject *dv) | 1185 dbmkeys_iter(dbmviewobject *dv) |
1081 { | 1186 { |
1082 if (dv->dv_dbm == NULL) { | 1187 if (dv->dv_dbm == NULL) { |
1083 Py_RETURN_NONE; | 1188 Py_RETURN_NONE; |
1084 } | 1189 } |
1085 return dbm_iter(dv->dv_dbm); | 1190 return dbm_iter(dv->dv_dbm); |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1157 | 1262 |
1158 PyDoc_STRVAR(isdisjoint_doc, | 1263 PyDoc_STRVAR(isdisjoint_doc, |
1159 "Return True if the view and the given iterable have a null intersection."); | 1264 "Return True if the view and the given iterable have a null intersection."); |
1160 | 1265 |
1161 static PyMethodDef dbmviews_methods[] = { | 1266 static PyMethodDef dbmviews_methods[] = { |
1162 {"isdisjoint", (PyCFunction)dbmviews_isdisjoint, METH_O, | 1267 {"isdisjoint", (PyCFunction)dbmviews_isdisjoint, METH_O, |
1163 isdisjoint_doc}, | 1268 isdisjoint_doc}, |
1164 {NULL, NULL} /* sentinel */ | 1269 {NULL, NULL} /* sentinel */ |
1165 }; | 1270 }; |
1166 | 1271 |
1167 PyTypeObject PyDbmKeys_Type = { | 1272 PyTypeObject DbmKeys_Type = { |
1168 PyVarObject_HEAD_INIT(&PyType_Type, 0) | 1273 PyVarObject_HEAD_INIT(&PyType_Type, 0) |
1169 "dbm_keys", /* tp_name */ | 1274 "dbm_keys", /* tp_name */ |
1170 sizeof(dbmviewobject), /* tp_basicsize */ | 1275 sizeof(dbmviewobject), /* tp_basicsize */ |
1171 0, /* tp_itemsize */ | 1276 0, /* tp_itemsize */ |
1172 /* methods */ | 1277 /* methods */ |
1173 (destructor)dbmview_dealloc, /* tp_dealloc */ | 1278 (destructor)dbmview_dealloc, /* tp_dealloc */ |
1174 0, /* tp_print */ | 1279 0, /* tp_print */ |
1175 0, /* tp_getattr */ | 1280 0, /* tp_getattr */ |
1176 0, /* tp_setattr */ | 1281 0, /* tp_setattr */ |
1177 0, /* tp_reserved */ | 1282 0, /* tp_reserved */ |
1178 0, /* tp_repr */ | 1283 0, /* tp_repr */ |
1179 0, /* tp_as_number */ | 1284 &dbmviews_as_number, /* tp_as_number */ |
1180 &dbmkeys_as_sequence, /* tp_as_sequence */ | 1285 &dbmkeys_as_sequence, /* tp_as_sequence */ |
1181 0, /* tp_as_mapping */ | 1286 0, /* tp_as_mapping */ |
1182 0, /* tp_hash */ | 1287 0, /* tp_hash */ |
1183 0, /* tp_call */ | 1288 0, /* tp_call */ |
1184 0, /* tp_str */ | 1289 0, /* tp_str */ |
1185 PyObject_GenericGetAttr, /* tp_getattro */ | 1290 PyObject_GenericGetAttr, /* tp_getattro */ |
1186 0, /* tp_setattro */ | 1291 0, /* tp_setattro */ |
1187 0, /* tp_as_buffer */ | 1292 0, /* tp_as_buffer */ |
1188 Py_TPFLAGS_DEFAULT, /* tp_flags */ | 1293 Py_TPFLAGS_DEFAULT, /* tp_flags */ |
1189 0, /* tp_doc */ | 1294 0, /* tp_doc */ |
1190 0, /* tp_traverse */ | 1295 0, /* tp_traverse */ |
1191 0, /* tp_clear */ | 1296 0, /* tp_clear */ |
1192 dbmview_richcompare, /* tp_richcompare */ | 1297 dbmview_richcompare, /* tp_richcompare */ |
1193 0, /* tp_weaklistoffset */ | 1298 0, /* tp_weaklistoffset */ |
1194 (getiterfunc)dbmkeys_iter, /* tp_iter */ | 1299 (getiterfunc)dbmkeys_iter, /* tp_iter */ |
1195 0, /* tp_iternext */ | 1300 0, /* tp_iternext */ |
1196 dbmviews_methods, /* tp_methods */ | 1301 dbmviews_methods, /* tp_methods */ |
1197 0, | 1302 0, |
1198 }; | 1303 }; |
1199 | 1304 |
1200 /* XXX Should return a set or a set view */ | 1305 /* XXX Should return a set or a set view */ |
1201 PyDoc_STRVAR(dbm_keys__doc__, | 1306 PyDoc_STRVAR(dbm_keys__doc__, |
1202 "keys() -> keys view\n\ | 1307 "keys() -> keys view\n\ |
1203 Get a set-like object providing a view on database's keys."); | 1308 Get a set-like object providing a view on the database's keys."); |
1204 | 1309 |
1205 static PyObject * | 1310 static PyObject * |
1206 dbmkeys_new(PyObject *dbm) | 1311 dbmkeys_new(PyObject *dbm) |
1207 { | 1312 { |
1208 return dbmview_new(dbm, &PyDbmKeys_Type); | 1313 return dbmview_new(dbm, &DbmKeys_Type); |
1209 } | 1314 } |
1210 | 1315 |
1211 | 1316 |
1212 /*** dbm_values ***/ | 1317 /*** dbm_values ***/ |
1213 | 1318 |
1214 static PyObject * | 1319 static PyObject * |
1215 dbmvalues_iter(dbmviewobject *dv) | 1320 dbmvalues_iter(dbmviewobject *dv) |
1216 { | 1321 { |
1217 if (dv->dv_dbm == NULL) { | 1322 if (dv->dv_dbm == NULL) { |
1218 Py_RETURN_NONE; | 1323 Py_RETURN_NONE; |
1219 } | 1324 } |
1220 return dbmiter_new(dv->dv_dbm, &DbmIterValue_Type); | 1325 return dbmiter_new(dv->dv_dbm, &DbmIterValue_Type); |
1221 } | 1326 } |
1222 | 1327 |
1223 static PySequenceMethods dbmvalues_as_sequence = { | 1328 static PySequenceMethods dbmvalues_as_sequence = { |
1224 (lenfunc)dbmview_len, /* sq_length */ | 1329 (lenfunc)dbmview_len, /* sq_length */ |
1225 0, /* sq_concat */ | 1330 0, /* sq_concat */ |
1226 0, /* sq_repeat */ | 1331 0, /* sq_repeat */ |
1227 0, /* sq_item */ | 1332 0, /* sq_item */ |
1228 0, /* sq_slice */ | 1333 0, /* sq_slice */ |
1229 0, /* sq_ass_item */ | 1334 0, /* sq_ass_item */ |
1230 0, /* sq_ass_slice */ | 1335 0, /* sq_ass_slice */ |
1231 0, /* sq_contains */ | 1336 0, /* sq_contains */ |
1232 }; | 1337 }; |
1233 | 1338 |
1234 PyTypeObject PyDbmValues_Type = { | 1339 PyTypeObject DbmValues_Type = { |
1235 PyVarObject_HEAD_INIT(&PyType_Type, 0) | 1340 PyVarObject_HEAD_INIT(&PyType_Type, 0) |
1236 "dbm_values", /* tp_name */ | 1341 "dbm_values", /* tp_name */ |
1237 sizeof(dbmviewobject), /* tp_basicsize */ | 1342 sizeof(dbmviewobject), /* tp_basicsize */ |
1238 0, /* tp_itemsize */ | 1343 0, /* tp_itemsize */ |
1239 /* methods */ | 1344 /* methods */ |
1240 (destructor)dbmview_dealloc, /* tp_dealloc */ | 1345 (destructor)dbmview_dealloc, /* tp_dealloc */ |
1241 0, /* tp_print */ | 1346 0, /* tp_print */ |
1242 0, /* tp_getattr */ | 1347 0, /* tp_getattr */ |
1243 0, /* tp_setattr */ | 1348 0, /* tp_setattr */ |
1244 0, /* tp_reserved */ | 1349 0, /* tp_reserved */ |
(...skipping 15 matching lines...) Expand all Loading... | |
1260 0, /* tp_weaklistoffset */ | 1365 0, /* tp_weaklistoffset */ |
1261 (getiterfunc)dbmvalues_iter, /* tp_iter */ | 1366 (getiterfunc)dbmvalues_iter, /* tp_iter */ |
1262 0, /* tp_iternext */ | 1367 0, /* tp_iternext */ |
1263 0, /* tp_methods */ | 1368 0, /* tp_methods */ |
1264 0, | 1369 0, |
1265 }; | 1370 }; |
1266 | 1371 |
1267 | 1372 |
1268 /*** dbm_items ***/ | 1373 /*** dbm_items ***/ |
1269 | 1374 |
1375 static int | |
1376 dbmitems_contains(dbmviewobject *dv, PyObject *obj) | |
1377 { | |
1378 PyObject *key, *value, *key_bytes, *value_bytes, *vrec_bytes; | |
1379 datum krec, vrec; | |
1380 int result; | |
1381 if (dv->dv_dbm == NULL) | |
1382 return 0; | |
1383 if (!PyTuple_Check(obj) || PyTuple_GET_SIZE(obj) != 2) | |
1384 return 0; | |
1385 key = PyTuple_GET_ITEM(obj, 0); | |
1386 value = PyTuple_GET_ITEM(obj, 1); | |
1387 if (PyUnicode_Check(key)) { | |
1388 key_bytes = _PyUnicode_AsDefaultEncodedString(key, NULL); | |
1389 if (key_bytes == NULL) | |
1390 return -1; | |
1391 } | |
1392 else | |
1393 key_bytes = key; | |
1394 if (!PyBytes_Check(key_bytes)) { | |
1395 PyErr_Format(PyExc_TypeError, | |
1396 "dbm key must be string, not %.100s", | |
1397 key->ob_type->tp_name); | |
1398 return -1; | |
1399 } | |
1400 krec.dptr = PyBytes_AS_STRING(key_bytes); | |
1401 krec.dsize = PyBytes_GET_SIZE(key_bytes); | |
1402 vrec = gdbm_fetch(dv->dv_dbm->di_dbm, krec); | |
1403 if (vrec.dptr != NULL) { | |
1404 if ((vrec_bytes = PyBytes_FromStringAndSize(vrec.dptr, | |
1405 vrec.dsize)) == NULL) | |
1406 return -1; | |
1407 if (PyUnicode_Check(value)) { | |
1408 value_bytes = _PyUnicode_AsDefaultEncodedString(value, NULL); | |
1409 if (value_bytes == NULL) { | |
1410 Py_DECREF(vrec_bytes); | |
1411 return -1; | |
1412 } | |
1413 } | |
1414 else | |
1415 value_bytes = value; | |
1416 result = PyObject_RichCompareBool(value_bytes, vrec_bytes, Py_EQ); | |
1417 Py_DECREF(vrec_bytes); | |
1418 return result; | |
1419 } | |
1420 return 0; | |
1421 } | |
1422 | |
1270 static PyObject * | 1423 static PyObject * |
1271 dbmitems_iter(dbmviewobject *dv) | 1424 dbmitems_iter(dbmviewobject *dv) |
1272 { | 1425 { |
1273 if (dv->dv_dbm == NULL) { | 1426 if (dv->dv_dbm == NULL) { |
1274 Py_RETURN_NONE; | 1427 Py_RETURN_NONE; |
1275 } | 1428 } |
1276 return dbmiter_new(dv->dv_dbm, &DbmIterItem_Type); | 1429 return dbmiter_new(dv->dv_dbm, &DbmIterItem_Type); |
1277 } | 1430 } |
1278 | 1431 |
1279 static PySequenceMethods dbmitems_as_sequence = { | 1432 static PySequenceMethods dbmitems_as_sequence = { |
1280 (lenfunc)dbmview_len, /* sq_length */ | 1433 (lenfunc)dbmview_len, /* sq_length */ |
1281 0, /* sq_concat */ | 1434 0, /* sq_concat */ |
1282 0, /* sq_repeat */ | 1435 0, /* sq_repeat */ |
1283 0, /* sq_item */ | 1436 0, /* sq_item */ |
1284 0, /* sq_slice */ | 1437 0, /* sq_slice */ |
1285 0, /* sq_ass_item */ | 1438 0, /* sq_ass_item */ |
1286 0, /* sq_ass_slice */ | 1439 0, /* sq_ass_slice */ |
1287 0, /* sq_contains */ | 1440 (objobjproc)dbmitems_contains, /* sq_contains */ |
1288 }; | 1441 }; |
1289 | 1442 |
1290 PyTypeObject PyDbmItems_Type = { | 1443 PyTypeObject DbmItems_Type = { |
1291 PyVarObject_HEAD_INIT(&PyType_Type, 0) | 1444 PyVarObject_HEAD_INIT(&PyType_Type, 0) |
1292 "dbm_items", /* tp_name */ | 1445 "dbm_items", /* tp_name */ |
1293 sizeof(dbmviewobject), /* tp_basicsize */ | 1446 sizeof(dbmviewobject), /* tp_basicsize */ |
1294 0, /* tp_itemsize */ | 1447 0, /* tp_itemsize */ |
1295 /* methods */ | 1448 /* methods */ |
1296 (destructor)dbmview_dealloc, /* tp_dealloc */ | 1449 (destructor)dbmview_dealloc, /* tp_dealloc */ |
1297 0, /* tp_print */ | 1450 0, /* tp_print */ |
1298 0, /* tp_getattr */ | 1451 0, /* tp_getattr */ |
1299 0, /* tp_setattr */ | 1452 0, /* tp_setattr */ |
1300 0, /* tp_reserved */ | 1453 0, /* tp_reserved */ |
1301 0, /* tp_repr */ | 1454 0, /* tp_repr */ |
1302 0, /* tp_as_number */ | 1455 &dbmviews_as_number, /* tp_as_number */ |
1303 &dbmitems_as_sequence, /* tp_as_sequence */ | 1456 &dbmitems_as_sequence, /* tp_as_sequence */ |
1304 0, /* tp_as_mapping */ | 1457 0, /* tp_as_mapping */ |
1305 0, /* tp_hash */ | 1458 0, /* tp_hash */ |
1306 0, /* tp_call */ | 1459 0, /* tp_call */ |
1307 0, /* tp_str */ | 1460 0, /* tp_str */ |
1308 PyObject_GenericGetAttr, /* tp_getattro */ | 1461 PyObject_GenericGetAttr, /* tp_getattro */ |
1309 0, /* tp_setattro */ | 1462 0, /* tp_setattro */ |
1310 0, /* tp_as_buffer */ | 1463 0, /* tp_as_buffer */ |
1311 Py_TPFLAGS_DEFAULT, /* tp_flags */ | 1464 Py_TPFLAGS_DEFAULT, /* tp_flags */ |
1312 0, /* tp_doc */ | 1465 0, /* tp_doc */ |
1313 0, /* tp_traverse */ | 1466 0, /* tp_traverse */ |
1314 0, /* tp_clear */ | 1467 0, /* tp_clear */ |
1315 dbmview_richcompare, /* tp_richcompare */ | 1468 dbmview_richcompare, /* tp_richcompare */ |
1316 0, /* tp_weaklistoffset */ | 1469 0, /* tp_weaklistoffset */ |
1317 (getiterfunc)dbmitems_iter, /* tp_iter */ | 1470 (getiterfunc)dbmitems_iter, /* tp_iter */ |
1318 0, /* tp_iternext */ | 1471 0, /* tp_iternext */ |
1319 dbmviews_methods, /* tp_methods */ | 1472 dbmviews_methods, /* tp_methods */ |
1320 0, | 1473 0, |
1321 }; | 1474 }; |
1322 | 1475 |
1323 PyDoc_STRVAR(dbm_items__doc__, | 1476 PyDoc_STRVAR(dbm_items__doc__, |
1324 "items() -> items view\n\ | 1477 "items() -> items view\n\ |
1325 Get a set-like object providing a view on database's items."); | 1478 Get a set-like object providing a view on the database's items."); |
1326 | 1479 |
1327 static PyObject * | 1480 static PyObject * |
1328 dbmitems_new(PyObject *dbm) | 1481 dbmitems_new(PyObject *dbm) |
1329 { | 1482 { |
1330 return dbmview_new(dbm, &PyDbmItems_Type); | 1483 return dbmview_new(dbm, &DbmItems_Type); |
1331 } | 1484 } |
1332 | 1485 |
1333 PyDoc_STRVAR(dbm_values__doc__, | 1486 PyDoc_STRVAR(dbm_values__doc__, |
1334 "values() -> values view\n\ | 1487 "values() -> values view\n\ |
1335 Get an object providing a view on database's values."); | 1488 Get an object providing a view on the database's values."); |
1336 | 1489 |
1337 static PyObject * | 1490 static PyObject * |
1338 dbmvalues_new(PyObject *dbm) | 1491 dbmvalues_new(PyObject *dbm) |
1339 { | 1492 { |
1340 return dbmview_new(dbm, &PyDbmValues_Type); | 1493 return dbmview_new(dbm, &DbmValues_Type); |
1341 } | 1494 } |
1342 | 1495 |
1343 static PyMethodDef dbm_methods[] = { | 1496 static PyMethodDef dbm_methods[] = { |
1344 {"close", (PyCFunction)dbm_close, METH_NOARGS, dbm_close__doc__}, | 1497 {"close", (PyCFunction)dbm_close, METH_NOARGS, dbm_close__doc__}, |
1345 {"keys", (PyCFunction)dbmkeys_new, METH_NOARGS, dbm_keys__doc__}, | 1498 {"keys", (PyCFunction)dbmkeys_new, METH_NOARGS, dbm_keys__doc__}, |
1346 {"firstkey", (PyCFunction)dbm_firstkey,METH_NOARGS, dbm_firstkey__doc__}, | 1499 {"firstkey", (PyCFunction)dbm_firstkey,METH_NOARGS, dbm_firstkey__doc__}, |
1347 {"nextkey", (PyCFunction)dbm_nextkey, METH_VARARGS, dbm_nextkey__doc__}, | 1500 {"nextkey", (PyCFunction)dbm_nextkey, METH_VARARGS, dbm_nextkey__doc__}, |
1348 {"reorganize",(PyCFunction)dbm_reorganize,METH_NOARGS, dbm_reorganize__doc__ }, | 1501 {"reorganize",(PyCFunction)dbm_reorganize,METH_NOARGS, dbm_reorganize__doc__ }, |
1349 {"sync", (PyCFunction)dbm_sync, METH_NOARGS, dbm_sync__doc__}, | 1502 {"sync", (PyCFunction)dbm_sync, METH_NOARGS, dbm_sync__doc__}, |
1350 {"get", (PyCFunction)dbm_get, METH_VARARGS, dbm_get__doc__}, | 1503 {"get", (PyCFunction)dbm_get, METH_VARARGS, dbm_get__doc__}, |
(...skipping 148 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1499 dbmmodule_methods, | 1652 dbmmodule_methods, |
1500 NULL, | 1653 NULL, |
1501 NULL, | 1654 NULL, |
1502 NULL, | 1655 NULL, |
1503 NULL | 1656 NULL |
1504 }; | 1657 }; |
1505 | 1658 |
1506 PyMODINIT_FUNC | 1659 PyMODINIT_FUNC |
1507 PyInit__gdbm(void) { | 1660 PyInit__gdbm(void) { |
1508 PyObject *m, *d, *s; | 1661 PyObject *m, *d, *s; |
1509 PyObject *coll_mod, *mapping_abc, *keysview_abc, *valuesview_abc, | |
1510 *itemsview_abc; | |
1511 | 1662 |
1512 if (PyType_Ready(&Dbmtype) < 0) | 1663 if (PyType_Ready(&Dbmtype) < 0) |
1513 return NULL; | 1664 return NULL; |
1514 | |
1515 if ((coll_mod = PyImport_ImportModule("collections")) == NULL) | |
1516 return NULL; | |
1517 if ((mapping_abc = PyObject_GetAttrString(coll_mod, | |
1518 "MutableMapping")) == NULL) { | |
1519 Py_DECREF(coll_mod); | |
1520 return NULL; | |
1521 } | |
1522 if ((keysview_abc = PyObject_GetAttrString(coll_mod, | |
1523 "KeysView")) == NULL) { | |
1524 Py_DECREF(coll_mod); | |
1525 return NULL; | |
1526 } | |
1527 if ((valuesview_abc = PyObject_GetAttrString(coll_mod, | |
1528 "ValuesView")) == NULL) { | |
1529 Py_DECREF(coll_mod); | |
1530 return NULL; | |
1531 } | |
1532 if ((itemsview_abc = PyObject_GetAttrString(coll_mod, | |
1533 "ItemsView")) == NULL) { | |
1534 Py_DECREF(coll_mod); | |
1535 return NULL; | |
1536 } | |
1537 Py_DECREF(coll_mod); | |
1538 if (PyObject_CallMethod(mapping_abc, "register", "O", &Dbmtype) == NULL) { | |
1539 Py_DECREF(mapping_abc); | |
1540 return NULL; | |
1541 } | |
1542 Py_DECREF(mapping_abc); | |
1543 | |
1544 if (PyObject_CallMethod(keysview_abc, "register", "O", | |
1545 &PyDbmKeys_Type) == NULL) { | |
1546 Py_DECREF(keysview_abc); | |
1547 return NULL; | |
1548 } | |
1549 Py_DECREF(keysview_abc); | |
1550 | |
1551 if (PyObject_CallMethod(valuesview_abc, "register", "O", | |
1552 &PyDbmValues_Type) == NULL) { | |
1553 Py_DECREF(valuesview_abc); | |
1554 return NULL; | |
1555 } | |
1556 Py_DECREF(valuesview_abc); | |
1557 | |
1558 if (PyObject_CallMethod(itemsview_abc, "register", "O", | |
1559 &PyDbmItems_Type) == NULL) { | |
1560 Py_DECREF(itemsview_abc); | |
1561 return NULL; | |
1562 } | |
1563 Py_DECREF(itemsview_abc); | |
1564 | 1665 |
1565 m = PyModule_Create(&_gdbmmodule); | 1666 m = PyModule_Create(&_gdbmmodule); |
1566 if (m == NULL) | 1667 if (m == NULL) |
1567 return NULL; | 1668 return NULL; |
1568 d = PyModule_GetDict(m); | 1669 d = PyModule_GetDict(m); |
1569 DbmError = PyErr_NewException("_gdbm.error", PyExc_IOError, NULL); | 1670 DbmError = PyErr_NewException("_gdbm.error", PyExc_IOError, NULL); |
1570 if (DbmError != NULL) { | 1671 if (DbmError != NULL) { |
1571 PyDict_SetItemString(d, "error", DbmError); | 1672 PyDict_SetItemString(d, "error", DbmError); |
1572 s = PyUnicode_FromString(dbmmodule_open_flags); | 1673 s = PyUnicode_FromString(dbmmodule_open_flags); |
1573 PyDict_SetItemString(d, "open_flags", s); | 1674 PyDict_SetItemString(d, "open_flags", s); |
1574 Py_DECREF(s); | 1675 Py_DECREF(s); |
1575 } | 1676 } |
1576 return m; | 1677 return m; |
1577 } | 1678 } |
LEFT | RIGHT |