Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity
cpython/Objects/mappingobject.c

1034 lines
23 KiB
C
Raw Blame History

/***********************************************************
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
The Netherlands.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI or Corporation for National Research Initiatives or
CNRI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.
While CWI is the initial source for this software, a modified version
is made available by the Corporation for National Research Initiatives
(CNRI) at the Internet address ftp://ftp.python.org.
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
******************************************************************/
/* Mapping object implementation; using a hash table */
/* This file should really be called "dictobject.c", since "mapping"
is the generic name for objects with an unorderred arbitrary key
set (just like lists are sequences), but since it improves (and was
originally derived from) a file by that name I had to change its
name. For the user these objects are still called "dictionaries". */
#include "Python.h"
/*
* MINSIZE is the minimum size of a mapping.
*/
#define MINSIZE 4
/*
Table of irreducible polynomials to efficiently cycle through
GF(2^n)-{0}, 2<=n<=30.
*/
static long polys[] = {
4 + 3,
8 + 3,
16 + 3,
32 + 5,
64 + 3,
128 + 3,
256 + 29,
512 + 17,
1024 + 9,
2048 + 5,
4096 + 83,
8192 + 27,
16384 + 43,
32768 + 3,
65536 + 45,
131072 + 9,
262144 + 39,
524288 + 39,
1048576 + 9,
2097152 + 5,
4194304 + 3,
8388608 + 33,
16777216 + 27,
33554432 + 9,
67108864 + 71,
134217728 + 39,
268435456 + 9,
536870912 + 5,
1073741824 + 83,
0
};
/* Object used as dummy key to fill deleted entries */
static PyObject *dummy; /* Initialized by first call to newmappingobject() */
/*
Invariant for entries: when in use, de_value is not NULL and de_key is
not NULL and not dummy; when not in use, de_value is NULL and de_key
is either NULL or dummy. A dummy key value cannot be replaced by
NULL, since otherwise other keys may be lost.
*/
typedef struct {
long me_hash;
PyObject *me_key;
PyObject *me_value;
#ifdef USE_CACHE_ALIGNED
long aligner;
#endif
} mappingentry;
/*
To ensure the lookup algorithm terminates, the table size must be a
prime number and there must be at least one NULL key in the table.
The value ma_fill is the number of non-NULL keys; ma_used is the number
of non-NULL, non-dummy keys.
To avoid slowing down lookups on a near-full table, we resize the table
when it is more than half filled.
*/
typedef struct {
PyObject_HEAD
int ma_fill;
int ma_used;
int ma_size;
int ma_poly;
mappingentry *ma_table;
} mappingobject;
PyObject *
PyDict_New()
{
register mappingobject *mp;
if (dummy == NULL) { /* Auto-initialize dummy */
dummy = PyString_FromString("<dummy key>");
if (dummy == NULL)
return NULL;
}
mp = PyObject_NEW(mappingobject, &PyDict_Type);
if (mp == NULL)
return NULL;
mp->ma_size = 0;
mp->ma_poly = 0;
mp->ma_table = NULL;
mp->ma_fill = 0;
mp->ma_used = 0;
return (PyObject *)mp;
}
/*
The basic lookup function used by all operations.
This is based on Algorithm D from Knuth Vol. 3, Sec. 6.4.
Open addressing is preferred over chaining since the link overhead for
chaining would be substantial (100% with typical malloc overhead).
However, instead of going through the table at constant steps, we cycle
through the values of GF(2^n)-{0}. This avoids modulo computations, being
much cheaper on RISC machines, without leading to clustering.
First a 32-bit hash value, 'sum', is computed from the key string.
The first character is added an extra time shifted by 8 to avoid hashing
single-character keys (often heavily used variables) too close together.
All arithmetic on sum should ignore overflow.
The initial probe index is then computed as sum mod the table size.
Subsequent probe indices use the values of x^i in GF(2^n) as an offset,
where x is a root. The initial value is derived from sum, too.
(This version is due to Reimer Behrends, some ideas are also due to
Jyrki Alakuijala.)
*/
static mappingentry *lookmapping Py_PROTO((mappingobject *, PyObject *, long));
static mappingentry *
lookmapping(mp, key, hash)
mappingobject *mp;
PyObject *key;
long hash;
{
register int i;
register unsigned incr;
register unsigned long sum = (unsigned long) hash;
register mappingentry *freeslot = NULL;
register unsigned int mask = mp->ma_size-1;
mappingentry *ep0 = mp->ma_table;
register mappingentry *ep;
/* We must come up with (i, incr) such that 0 <= i < ma_size
and 0 < incr < ma_size and both are a function of hash */
i = (~sum) & mask;
/* We use ~sum instead if sum, as degenerate hash functions, such
as for ints <sigh>, can have lots of leading zeros. It's not
really a performance risk, but better safe than sorry. */
ep = &ep0[i];
if (ep->me_key == NULL)
return ep;
if (ep->me_key == dummy)
freeslot = ep;
else if (ep->me_key == key ||
(ep->me_hash == hash &&
PyObject_Compare(ep->me_key, key) == 0))
{
return ep;
}
/* Derive incr from sum, just to make it more arbitrary. Note that
incr must not be 0, or we will get into an infinite loop.*/
incr = (sum ^ (sum >> 3)) & mask;
if (!incr)
incr = mask;
if (incr > mask) /* Cycle through GF(2^n)-{0} */
incr ^= mp->ma_poly; /* This will implicitly clear the
highest bit */
for (;;) {
ep = &ep0[(i+incr)&mask];
if (ep->me_key == NULL) {
if (freeslot != NULL)
return freeslot;
else
return ep;
}
if (ep->me_key == dummy) {
if (freeslot == NULL)
freeslot = ep;
}
else if (ep->me_key == key ||
(ep->me_hash == hash &&
PyObject_Compare(ep->me_key, key) == 0)) {
return ep;
}
/* Cycle through GF(2^n)-{0} */
incr = incr << 1;
if (incr > mask)
incr ^= mp->ma_poly;
}
}
/*
Internal routine to insert a new item into the table.
Used both by the internal resize routine and by the public insert routine.
Eats a reference to key and one to value.
*/
static void insertmapping
Py_PROTO((mappingobject *, PyObject *, long, PyObject *));
static void
insertmapping(mp, key, hash, value)
register mappingobject *mp;
PyObject *key;
long hash;
PyObject *value;
{
PyObject *old_value;
register mappingentry *ep;
ep = lookmapping(mp, key, hash);
if (ep->me_value != NULL) {
old_value = ep->me_value;
ep->me_value = value;
Py_DECREF(old_value); /* which **CAN** re-enter */
Py_DECREF(key);
}
else {
if (ep->me_key == NULL)
mp->ma_fill++;
else
Py_DECREF(ep->me_key);
ep->me_key = key;
ep->me_hash = hash;
ep->me_value = value;
mp->ma_used++;
}
}
/*
Restructure the table by allocating a new table and reinserting all
items again. When entries have been deleted, the new table may
actually be smaller than the old one.
*/
static int mappingresize Py_PROTO((mappingobject *));
static int
mappingresize(mp)
mappingobject *mp;
{
register int oldsize = mp->ma_size;
register int newsize, newpoly;
register mappingentry *oldtable = mp->ma_table;
register mappingentry *newtable;
register mappingentry *ep;
register int i;
newsize = mp->ma_size;
for (i = 0, newsize = MINSIZE; ; i++, newsize <<= 1) {
if (i > sizeof(polys)/sizeof(polys[0])) {
/* Ran out of polynomials */
PyErr_NoMemory();
return -1;
}
if (newsize > mp->ma_used*2) {
newpoly = polys[i];
break;
}
}
newtable = (mappingentry *) calloc(sizeof(mappingentry), newsize);
if (newtable == NULL) {
PyErr_NoMemory();
return -1;
}
mp->ma_size = newsize;
mp->ma_poly = newpoly;
mp->ma_table = newtable;
mp->ma_fill = 0;
mp->ma_used = 0;
/* Make two passes, so we can avoid decrefs
(and possible side effects) till the table is copied */
for (i = 0, ep = oldtable; i < oldsize; i++, ep++) {
if (ep->me_value != NULL)
insertmapping(mp,ep->me_key,ep->me_hash,ep->me_value);
}
for (i = 0, ep = oldtable; i < oldsize; i++, ep++) {
if (ep->me_value == NULL)
Py_XDECREF(ep->me_key);
}
PyMem_XDEL(oldtable);
return 0;
}
PyObject *
PyDict_GetItem(op, key)
PyObject *op;
PyObject *key;
{
long hash;
if (!PyDict_Check(op)) {
PyErr_BadInternalCall();
return NULL;
}
if (((mappingobject *)op)->ma_table == NULL)
return NULL;
#ifdef CACHE_HASH
if (!PyString_Check(key) ||
(hash = ((PyStringObject *) key)->ob_shash) == -1)
#endif
{
hash = PyObject_Hash(key);
if (hash == -1)
return NULL;
}
return lookmapping((mappingobject *)op, key, hash) -> me_value;
}
int
PyDict_SetItem(op, key, value)
register PyObject *op;
PyObject *key;
PyObject *value;
{
register mappingobject *mp;
register long hash;
if (!PyDict_Check(op)) {
PyErr_BadInternalCall();
return -1;
}
mp = (mappingobject *)op;
#ifdef CACHE_HASH
if (PyString_Check(key)) {
#ifdef INTERN_STRINGS
if (((PyStringObject *)key)->ob_sinterned != NULL) {
key = ((PyStringObject *)key)->ob_sinterned;
hash = ((PyStringObject *)key)->ob_shash;
}
else
#endif
{
hash = ((PyStringObject *)key)->ob_shash;
if (hash == -1)
hash = PyObject_Hash(key);
}
}
else
#endif
{
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
}
/* if fill >= 2/3 size, resize */
if (mp->ma_fill*3 >= mp->ma_size*2) {
if (mappingresize(mp) != 0) {
if (mp->ma_fill+1 > mp->ma_size)
return -1;
}
}
Py_INCREF(value);
Py_INCREF(key);
insertmapping(mp, key, hash, value);
return 0;
}
int
PyDict_DelItem(op, key)
PyObject *op;
PyObject *key;
{
register mappingobject *mp;
register long hash;
register mappingentry *ep;
PyObject *old_value, *old_key;
if (!PyDict_Check(op)) {
PyErr_BadInternalCall();
return -1;
}
#ifdef CACHE_HASH
if (!PyString_Check(key) ||
(hash = ((PyStringObject *) key)->ob_shash) == -1)
#endif
{
hash = PyObject_Hash(key);
if (hash == -1)
return -1;
}
mp = (mappingobject *)op;
if (((mappingobject *)op)->ma_table == NULL)
goto empty;
ep = lookmapping(mp, key, hash);
if (ep->me_value == NULL) {
empty:
PyErr_SetObject(PyExc_KeyError, key);
return -1;
}
old_key = ep->me_key;
Py_INCREF(dummy);
ep->me_key = dummy;
old_value = ep->me_value;
ep->me_value = NULL;
mp->ma_used--;
Py_DECREF(old_value);
Py_DECREF(old_key);
return 0;
}
void
PyDict_Clear(op)
PyObject *op;
{
int i, n;
register mappingentry *table;
mappingobject *mp;
if (!PyDict_Check(op))
return;
mp = (mappingobject *)op;
table = mp->ma_table;
if (table == NULL)
return;
n = mp->ma_size;
mp->ma_size = mp->ma_used = mp->ma_fill = 0;
mp->ma_table = NULL;
for (i = 0; i < n; i++) {
Py_XDECREF(table[i].me_key);
Py_XDECREF(table[i].me_value);
}
PyMem_DEL(table);
}
int
PyDict_Next(op, ppos, pkey, pvalue)
PyObject *op;
int *ppos;
PyObject **pkey;
PyObject **pvalue;
{
int i;
register mappingobject *mp;
if (!PyDict_Check(op))
return 0;
mp = (mappingobject *)op;
i = *ppos;
if (i < 0)
return 0;
while (i < mp->ma_size && mp->ma_table[i].me_value == NULL)
i++;
*ppos = i+1;
if (i >= mp->ma_size)
return 0;
if (pkey)
*pkey = mp->ma_table[i].me_key;
if (pvalue)
*pvalue = mp->ma_table[i].me_value;
return 1;
}
/* Methods */
static void
mapping_dealloc(mp)
register mappingobject *mp;
{
register int i;
register mappingentry *ep;
for (i = 0, ep = mp->ma_table; i < mp->ma_size; i++, ep++) {
if (ep->me_key != NULL)
Py_DECREF(ep->me_key);
if (ep->me_value != NULL)
Py_DECREF(ep->me_value);
}
PyMem_XDEL(mp->ma_table);
PyMem_DEL(mp);
}
static int
mapping_print(mp, fp, flags)
register mappingobject *mp;
register FILE *fp;
register int flags;
{
register int i;
register int any;
register mappingentry *ep;
fprintf(fp, "{");
any = 0;
for (i = 0, ep = mp->ma_table; i < mp->ma_size; i++, ep++) {
if (ep->me_value != NULL) {
if (any++ > 0)
fprintf(fp, ", ");
if (PyObject_Print((PyObject *)ep->me_key, fp, 0) != 0)
return -1;
fprintf(fp, ": ");
if (PyObject_Print(ep->me_value, fp, 0) != 0)
return -1;
}
}
fprintf(fp, "}");
return 0;
}
static PyObject *
mapping_repr(mp)
mappingobject *mp;
{
auto PyObject *v;
PyObject *sepa, *colon;
register int i;
register int any;
register mappingentry *ep;
v = PyString_FromString("{");
sepa = PyString_FromString(", ");
colon = PyString_FromString(": ");
any = 0;
for (i = 0, ep = mp->ma_table; i < mp->ma_size && v; i++, ep++) {
if (ep->me_value != NULL) {
if (any++)
PyString_Concat(&v, sepa);
PyString_ConcatAndDel(&v, PyObject_Repr(ep->me_key));
PyString_Concat(&v, colon);
PyString_ConcatAndDel(&v, PyObject_Repr(ep->me_value));
}
}
PyString_ConcatAndDel(&v, PyString_FromString("}"));
Py_XDECREF(sepa);
Py_XDECREF(colon);
return v;
}
static int
mapping_length(mp)
mappingobject *mp;
{
return mp->ma_used;
}
static PyObject *
mapping_subscript(mp, key)
mappingobject *mp;
register PyObject *key;
{
PyObject *v;
long hash;
if (mp->ma_table == NULL) {
PyErr_SetObject(PyExc_KeyError, key);
return NULL;
}
#ifdef CACHE_HASH
if (!PyString_Check(key) ||
(hash = ((PyStringObject *) key)->ob_shash) == -1)
#endif
{
hash = PyObject_Hash(key);
if (hash == -1)
return NULL;
}
v = lookmapping(mp, key, hash) -> me_value;
if (v == NULL)
PyErr_SetObject(PyExc_KeyError, key);
else
Py_INCREF(v);
return v;
}
static int
mapping_ass_sub(mp, v, w)
mappingobject *mp;
PyObject *v, *w;
{
if (w == NULL)
return PyDict_DelItem((PyObject *)mp, v);
else
return PyDict_SetItem((PyObject *)mp, v, w);
}
static PyMappingMethods mapping_as_mapping = {
(inquiry)mapping_length, /*mp_length*/
(binaryfunc)mapping_subscript, /*mp_subscript*/
(objobjargproc)mapping_ass_sub, /*mp_ass_subscript*/
};
static PyObject *
mapping_keys(mp, args)
register mappingobject *mp;
PyObject *args;
{
register PyObject *v;
register int i, j;
if (!PyArg_NoArgs(args))
return NULL;
v = PyList_New(mp->ma_used);
if (v == NULL)
return NULL;
for (i = 0, j = 0; i < mp->ma_size; i++) {
if (mp->ma_table[i].me_value != NULL) {
PyObject *key = mp->ma_table[i].me_key;
Py_INCREF(key);
PyList_SetItem(v, j, key);
j++;
}
}
return v;
}
static PyObject *
mapping_values(mp, args)
register mappingobject *mp;
PyObject *args;
{
register PyObject *v;
register int i, j;
if (!PyArg_NoArgs(args))
return NULL;
v = PyList_New(mp->ma_used);
if (v == NULL)
return NULL;
for (i = 0, j = 0; i < mp->ma_size; i++) {
if (mp->ma_table[i].me_value != NULL) {
PyObject *value = mp->ma_table[i].me_value;
Py_INCREF(value);
PyList_SetItem(v, j, value);
j++;
}
}
return v;
}
static PyObject *
mapping_items(mp, args)
register mappingobject *mp;
PyObject *args;
{
register PyObject *v;
register int i, j;
if (!PyArg_NoArgs(args))
return NULL;
v = PyList_New(mp->ma_used);
if (v == NULL)
return NULL;
for (i = 0, j = 0; i < mp->ma_size; i++) {
if (mp->ma_table[i].me_value != NULL) {
PyObject *key = mp->ma_table[i].me_key;
PyObject *value = mp->ma_table[i].me_value;
PyObject *item = PyTuple_New(2);
if (item == NULL) {
Py_DECREF(v);
return NULL;
}
Py_INCREF(key);
PyTuple_SetItem(item, 0, key);
Py_INCREF(value);
PyTuple_SetItem(item, 1, value);
PyList_SetItem(v, j, item);
j++;
}
}
return v;
}
int
PyDict_Size(mp)
PyObject *mp;
{
if (mp == NULL || !PyDict_Check(mp)) {
PyErr_BadInternalCall();
return 0;
}
return ((mappingobject *)mp)->ma_used;
}
PyObject *
PyDict_Keys(mp)
PyObject *mp;
{
if (mp == NULL || !PyDict_Check(mp)) {
PyErr_BadInternalCall();
return NULL;
}
return mapping_keys((mappingobject *)mp, (PyObject *)NULL);
}
PyObject *
PyDict_Values(mp)
PyObject *mp;
{
if (mp == NULL || !PyDict_Check(mp)) {
PyErr_BadInternalCall();
return NULL;
}
return mapping_values((mappingobject *)mp, (PyObject *)NULL);
}
PyObject *
PyDict_Items(mp)
PyObject *mp;
{
if (mp == NULL || !PyDict_Check(mp)) {
PyErr_BadInternalCall();
return NULL;
}
return mapping_items((mappingobject *)mp, (PyObject *)NULL);
}
#define NEWCMP
#ifdef NEWCMP
/* Subroutine which returns the smallest key in a for which b's value
is different or absent. The value is returned too, through the
pval argument. No reference counts are incremented. */
static PyObject *
characterize(a, b, pval)
mappingobject *a;
mappingobject *b;
PyObject **pval;
{
PyObject *diff = NULL;
int i;
*pval = NULL;
for (i = 0; i < a->ma_size; i++) {
if (a->ma_table[i].me_value != NULL) {
PyObject *key = a->ma_table[i].me_key;
PyObject *aval, *bval;
if (diff != NULL && PyObject_Compare(key, diff) > 0)
continue;
aval = a->ma_table[i].me_value;
bval = PyDict_GetItem((PyObject *)b, key);
if (bval == NULL || PyObject_Compare(aval, bval) != 0)
{
diff = key;
*pval = aval;
}
}
}
return diff;
}
static int
mapping_compare(a, b)
mappingobject *a, *b;
{
PyObject *adiff, *bdiff, *aval, *bval;
int res;
/* Compare lengths first */
if (a->ma_used < b->ma_used)
return -1; /* a is shorter */
else if (a->ma_used > b->ma_used)
return 1; /* b is shorter */
/* Same length -- check all keys */
adiff = characterize(a, b, &aval);
if (adiff == NULL)
return 0; /* a is a subset with the same length */
bdiff = characterize(b, a, &bval);
/* bdiff == NULL would be impossible now */
res = PyObject_Compare(adiff, bdiff);
if (res == 0)
res = PyObject_Compare(aval, bval);
return res;
}
#else /* !NEWCMP */
static int
mapping_compare(a, b)
mappingobject *a, *b;
{
PyObject *akeys, *bkeys;
int i, n, res;
if (a == b)
return 0;
if (a->ma_used == 0) {
if (b->ma_used != 0)
return -1;
else
return 0;
}
else {
if (b->ma_used == 0)
return 1;
}
akeys = mapping_keys(a, (PyObject *)NULL);
bkeys = mapping_keys(b, (PyObject *)NULL);
if (akeys == NULL || bkeys == NULL) {
/* Oops, out of memory -- what to do? */
/* For now, sort on address! */
Py_XDECREF(akeys);
Py_XDECREF(bkeys);
if (a < b)
return -1;
else
return 1;
}
PyList_Sort(akeys);
PyList_Sort(bkeys);
n = a->ma_used < b->ma_used ? a->ma_used : b->ma_used; /* smallest */
res = 0;
for (i = 0; i < n; i++) {
PyObject *akey, *bkey, *aval, *bval;
long ahash, bhash;
akey = PyList_GetItem(akeys, i);
bkey = PyList_GetItem(bkeys, i);
res = PyObject_Compare(akey, bkey);
if (res != 0)
break;
#ifdef CACHE_HASH
if (!PyString_Check(akey) ||
(ahash = ((PyStringObject *) akey)->ob_shash) == -1)
#endif
{
ahash = PyObject_Hash(akey);
if (ahash == -1)
PyErr_Clear(); /* Don't want errors here */
}
#ifdef CACHE_HASH
if (!PyString_Check(bkey) ||
(bhash = ((PyStringObject *) bkey)->ob_shash) == -1)
#endif
{
bhash = PyObject_Hash(bkey);
if (bhash == -1)
PyErr_Clear(); /* Don't want errors here */
}
aval = lookmapping(a, akey, ahash) -> me_value;
bval = lookmapping(b, bkey, bhash) -> me_value;
res = PyObject_Compare(aval, bval);
if (res != 0)
break;
}
if (res == 0) {
if (a->ma_used < b->ma_used)
res = -1;
else if (a->ma_used > b->ma_used)
res = 1;
}
Py_DECREF(akeys);
Py_DECREF(bkeys);
return res;
}
#endif /* !NEWCMP */
static PyObject *
mapping_has_key(mp, args)
register mappingobject *mp;
PyObject *args;
{
PyObject *key;
long hash;
register long ok;
if (!PyArg_Parse(args, "O", &key))
return NULL;
#ifdef CACHE_HASH
if (!PyString_Check(key) ||
(hash = ((PyStringObject *) key)->ob_shash) == -1)
#endif
{
hash = PyObject_Hash(key);
if (hash == -1)
return NULL;
}
ok = mp->ma_size != 0 && lookmapping(mp, key, hash)->me_value != NULL;
return PyInt_FromLong(ok);
}
static PyObject *
mapping_clear(mp, args)
register mappingobject *mp;
PyObject *args;
{
if (!PyArg_NoArgs(args))
return NULL;
PyDict_Clear((PyObject *)mp);
Py_INCREF(Py_None);
return Py_None;
}
static PyMethodDef mapp_methods[] = {
{"clear", (PyCFunction)mapping_clear},
{"has_key", (PyCFunction)mapping_has_key},
{"items", (PyCFunction)mapping_items},
{"keys", (PyCFunction)mapping_keys},
{"values", (PyCFunction)mapping_values},
{NULL, NULL} /* sentinel */
};
static PyObject *
mapping_getattr(mp, name)
mappingobject *mp;
char *name;
{
return Py_FindMethod(mapp_methods, (PyObject *)mp, name);
}
PyTypeObject PyDict_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
"dictionary",
sizeof(mappingobject),
0,
(destructor)mapping_dealloc, /*tp_dealloc*/
(printfunc)mapping_print, /*tp_print*/
(getattrfunc)mapping_getattr, /*tp_getattr*/
0, /*tp_setattr*/
(cmpfunc)mapping_compare, /*tp_compare*/
(reprfunc)mapping_repr, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
&mapping_as_mapping, /*tp_as_mapping*/
};
/* For backward compatibility with old dictionary interface */
static PyObject *last_name_object;
static char *last_name_char; /* NULL or == getstringvalue(last_name_object) */
PyObject *
PyObject_GetAttr(v, name)
PyObject *v;
PyObject *name;
{
if (v->ob_type->tp_getattro != NULL)
return (*v->ob_type->tp_getattro)(v, name);
if (name != last_name_object) {
Py_XDECREF(last_name_object);
Py_INCREF(name);
last_name_object = name;
last_name_char = PyString_AsString(name);
}
return PyObject_GetAttrString(v, last_name_char);
}
int
PyObject_SetAttr(v, name, value)
PyObject *v;
PyObject *name;
PyObject *value;
{
int err;
Py_INCREF(name);
PyString_InternInPlace(&name);
if (v->ob_type->tp_setattro != NULL)
err = (*v->ob_type->tp_setattro)(v, name, value);
else {
if (name != last_name_object) {
Py_XDECREF(last_name_object);
Py_INCREF(name);
last_name_object = name;
last_name_char = PyString_AsString(name);
}
err = PyObject_SetAttrString(v, last_name_char, value);
}
Py_DECREF(name);
return err;
}
PyObject *
PyDict_GetItemString(v, key)
PyObject *v;
char *key;
{
if (key != last_name_char) {
Py_XDECREF(last_name_object);
last_name_object = PyString_FromString(key);
if (last_name_object == NULL) {
last_name_char = NULL;
return NULL;
}
PyString_InternInPlace(&last_name_object);
last_name_char = PyString_AsString(last_name_object);
}
return PyDict_GetItem(v, last_name_object);
}
int
PyDict_SetItemString(v, key, item)
PyObject *v;
char *key;
PyObject *item;
{
if (key != last_name_char) {
Py_XDECREF(last_name_object);
last_name_object = PyString_FromString(key);
if (last_name_object == NULL) {
last_name_char = NULL;
return -1;
}
PyString_InternInPlace(&last_name_object);
last_name_char = PyString_AsString(last_name_object);
}
return PyDict_SetItem(v, last_name_object, item);
}
int
PyDict_DelItemString(v, key)
PyObject *v;
char *key;
{
if (key != last_name_char) {
Py_XDECREF(last_name_object);
last_name_object = PyString_FromString(key);
if (last_name_object == NULL) {
last_name_char = NULL;
return -1;
}
last_name_char = PyString_AsString(last_name_object);
}
return PyDict_DelItem(v, last_name_object);
}
Reference in New Issue View Git Blame Copy Permalink