# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
-#
+#
# mLib/Python is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
-#
+#
# You should have received a copy of the GNU General Public License
# along with mLib/Python; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-cdef extern from 'mLib/sym.h':
- ctypedef struct sym_table:
- pass
- ctypedef struct sym_base:
- pass
- ctypedef struct sym_iter:
- pass
- void sym_create(sym_table *t)
- void sym_destroy(sym_table *t)
- void *sym_find(sym_table *t, char *n, long l, int sz, unsigned *f)
- void sym_remove(sym_table *t, void *b)
- char *SYM_NAME(void *b)
- int SYM_LEN(void *b)
- void sym_mkiter(sym_iter *i, sym_table *t)
- void *sym_next(sym_iter *i)
-
-cdef extern from 'grim.h':
- int PSIZEOF(void *p)
-
-cdef extern from 'Python.h':
- int PyObject_AsReadBuffer(obj, void **buf, int *len) except -1
- PyString_FromStringAndSize(char *p, int n)
- ctypedef struct PyObject:
- pass
- void Py_INCREF(PyObject *obj)
- void Py_DECREF(PyObject *obj)
-
-cdef struct entry:
+cdef struct _sym_entry:
sym_base _b
PyObject *v
-cdef entry *_find(sym_table *t, object k, unsigned *f) except ?NULL:
- cdef void *p
- cdef int n
- cdef entry *e
- PyObject_AsReadBuffer(key, &p, &n)
- if f:
- f[0] = 0
- e = <entry *>sym_find(t, <char *>p, n, PSIZEOF(e), f)
- if not f[0]:
- e.v = NULL
- else:
- e = <entry *>sym_find(t, <char *>p, n, 0, NULL)
- return e
-
-cdef _eget(entry *e):
- Py_INCREF(e.v)
- return <object>e.v
-
-cdef void _eset(entry *e, v):
- if e.v:
- Py_DECREF(e.v)
- e.v = <PyObject *>v
- Py_INCREF(e.v)
-
-cdef void _edel(sym_table *t, entry *e):
- if e.v:
- Py_DECREF(e.v)
- sym_remove(t, <void *>e)
-
-cdef _key(entry *e):
- return PyString_FromStringAndSize(SYM_NAME(<void *>e), SYM_LEN(<void *>e))
-
-cdef class Table:
+cdef class SymTable (Mapping):
cdef sym_table _t
- def __new__(me, *hunoz, **hukairz):
+ cdef int _init(me) except -1:
sym_create(&me._t)
- def __init__(me, stuff = None, **kw):
- me.update(stuff, kw)
- def __getitem__(me, key):
- cdef entry *e
- e = _find(&me._t, key, NULL)
- if not e:
- raise KeyError, key
- return _eget(e)
- def __setitem__(me, key, value):
- cdef unsigned f
- _eset(_find(&me._t, key, &f), value)
- def __delitem__(me, key):
- cdef entry *e
- cdef unsigned f
- e = _find(&me._t, key, &f)
- if not e:
- raise KeyError, key
- _edel(&me._t, e)
- def get(me, key, default = None):
- cdef entry *e
- e = _find(&me._t, key, NULL)
- if not e:
- return default
- return _eget(e)
- def setdefault(me, key, default = None):
- cdef entry *e
- cdef unsigned f
- e = _find(&me._t, key, &f)
+ return 0
+ cdef void *_find(me, object key, unsigned *f) except NULL:
+ cdef void *p
+ cdef int n
+ cdef _sym_entry *e
+ PyObject_AsReadBuffer(key, &p, &n)
if f:
- return _eget(e)
+ f[0] = 0
+ e = <_sym_entry *>sym_find(&me._t, <char *>p, n, PSIZEOF(e), f)
+ if not f[0]:
+ e.v = NULL
else:
- _eset(e, default)
- return default
- def pop(me, key, default = None):
- cdef entry *e
- e = _find(&me._t, key, NULL)
- if not e:
- return default
- rc = _eget(e)
- _edel(&me._t, e)
- return rc
- def popitem(me):
- cdef entry *e
- cdef sym_iter i
- sym_mkiter(&i, &me._t)
- e = <entry *>sym_next(&i)
- if not e:
- raise ValueError, 'popitem(): table is empty'
- return _key(e), _eget(e)
- def keys(me):
- cdef sym_iter i
- cdef entry *e
- l = []
- sym_mkiter(&i, &me._t)
- while 1:
- e = <entry *>sym_next(&i)
- if not e:
- break
- l.append(_key(e))
- return l
- def values(me):
- cdef sym_iter i
- cdef entry *e
- l = []
- sym_mkiter(&i, &me._t)
- while 1:
- e = <entry *>sym_next(&i)
- if not e:
- break
- l.append(_eget(e))
- return l
- def items(me):
- cdef sym_iter i
- cdef entry *e
- l = []
- sym_mkiter(&i, &me._t)
- while 1:
- e = <entry *>sym_next(&i)
- if not e:
- break
- l.append((_key(e), _eget(e)))
- return l
- def clear(me):
- cdef sym_iter i
- cdef entry *e
- sym_mkiter(&i, &me._t)
- while 1:
- e = <entry *>sym_next(&i)
- if not e:
- break
- _edel(&me._t, e)
- return me
- def __dealloc__(me):
- cdef sym_iter i
- cdef entry *e
- sym_mkiter(&i, &me._t)
- while 1:
- e = <entry *>sym_next(&i)
- if not e:
- break
- _edel(&me._t, e)
- sym_destroy(&me._t)
- def iterkeys(me):
- return KeyIter(me)
- def __iter__(me):
- return KeyIter(me)
- def itervalues(me):
- return ValueIter(me)
- def iteritems(me):
- return ItemIter(me)
- def update(me, stuff = None, **kw):
- cdef unsigned f
- if stuff is None:
- pass
- elif hasattr(stuff, 'itemiter'):
- for k, v in stuff.itemiter:
- _eset(_find(&me._t, k, &f), v)
- elif hasattr(stuff, 'keys'):
- for k in stuff.keys():
- _eset(_find(&me._t, k, &f), stuff[k])
- else:
- for k, v in stuff:
- _eset(_find(&me._t, k, &f), v)
- for k, v in kw.iteritems():
- _eset(_find(&me._t, k, &f), v)
- return me
-
-cdef class KeyIter:
- cdef Table _t
- cdef sym_iter _i
- def __new__(me, Table t):
- me._t = t
- sym_mkiter(&me._i, &t._t)
- def __iter__(me):
- return me
- def __next__(me):
- cdef entry *e
- e = <entry *>sym_next(&me._i)
- if not e:
- raise StopIteration
- return _key(e)
-
-cdef class ValueIter:
- cdef Table _t
- cdef sym_iter _i
- def __new__(me, Table t):
- me._t = t
- sym_mkiter(&me._i, &t._t)
- def __iter__(me):
- return me
- def __next__(me):
- cdef entry *e
- e = <entry *>sym_next(&me._i)
- if not e:
- raise StopIteration
- return _eget(e)
+ e = <_sym_entry *>sym_find(&me._t, <char *>p, n, 0, NULL)
+ return <void *>e
+ cdef object _key(me, void *e):
+ return PyString_FromStringAndSize(SYM_NAME(e), SYM_LEN(e))
+ cdef object _value(me, void *e):
+ cdef _sym_entry *ee
+ ee = <_sym_entry *>e
+ Py_INCREF(ee.v)
+ return <object>ee.v
+ cdef void _setval(me, void *e, object val):
+ cdef _sym_entry *ee
+ ee = <_sym_entry *>e
+ if ee.v:
+ Py_DECREF(ee.v)
+ ee.v = <PyObject *>v
+ Py_INCREF(ee.v)
+ cdef void _del(me, void *e):
+ cdef _sym_entry *ee
+ ee = <_sym_entry *>e
+ if ee.v:
+ Py_DECREF(ee.v)
+ sym_remove(&me._t, <void *>ee)
+ cdef _MapIterator _iter(me):
+ return _SymIter(me)
-cdef class ItemIter:
- cdef Table _t
- cdef sym_iter _i
- def __new__(me, Table t):
- me._t = t
- sym_mkiter(&me._i, &t._t)
- def __iter__(me):
- return me
- def __next__(me):
- cdef entry *e
- e = <entry *>sym_next(&me._i)
- if not e:
- raise StopIteration
- return _key(e), _eget(e)
+cdef class _SymIter (_MapIterator):
+ cdef SymTable t
+ cdef sym_iter i
+ def __new__(me, SymTable t):
+ me.t = t
+ sym_mkiter(&me.i, &me.t._t)
+ cdef void *_next(me):
+ return sym_next(&me.i)
#----- That's all, folks ----------------------------------------------------
~mdw / mLib-python / blobdiff