static int
trie_ass_sub(trieobject *mp, PyObject *py_key, PyObject *py_value)
{
unsigned char *key;
PyObject *py_prev;
/* Make sure key is a string. */
if(!PyString_Check(py_key)) {
PyErr_SetString(PyExc_TypeError, "key must be a string");
return -1;
}
key = (unsigned char *)PyString_AS_STRING((char *)py_key);
/* Check to see whether something already exists at that key. If
there's already an object there, then I will have to remove it.
*/
py_prev = (PyObject *)Trie_get(mp->trie, key);
if(py_prev) {
Py_DECREF(py_prev);
}
/* The client wants to delete a key from a dictionary. The Trie
API doesn't support this, so I will just overwrite it with
NULL. */
if(!py_value) {
/* If the key doesn't exist, raise a KeyError. */
if(!py_prev) {
PyErr_SetString(PyExc_KeyError, (char *)key);
return -1;
}
Trie_set(mp->trie, key, NULL);
}
/* The client wants to set a key in the dictionary. */
else {
Py_INCREF(py_value);
if(Trie_set(mp->trie, key, py_value)) {
PyErr_SetString(PyExc_AssertionError, "error setting trie");
return -1;
}
}
return 0;
}
static PyObject *
trie_subscript(trieobject *mp, PyObject *py_key)
{
const char *key;
PyObject *py_value;
/* Make sure key is a string. */
#ifdef IS_PY3K
if(!PyUnicode_Check(py_key)) {
#else
if(!PyString_Check(py_key)) {
#endif
PyErr_SetString(PyExc_TypeError, "key must be a string");
return NULL;
}
#ifdef IS_PY3K
/* TODO - Review next line for buffer usage */
key = PyBytes_AS_STRING(PyUnicode_AsASCIIString(py_key));
#else
key = PyString_AS_STRING(py_key);
#endif
py_value = Trie_get(mp->trie, key);
if(py_value == NULL)
PyErr_SetString(PyExc_KeyError, key);
else
Py_INCREF(py_value);
return py_value;
}
static int
trie_ass_sub(trieobject *mp, PyObject *py_key, PyObject *py_value)
{
int result = -1;
const char *key;
PyObject *py_prev;
#ifdef IS_PY3K
PyObject* bytes;
#endif
/* Make sure key is a string. */
#ifdef IS_PY3K
if(!PyUnicode_Check(py_key)) {
#else
if(!PyString_Check(py_key)) {
#endif
PyErr_SetString(PyExc_TypeError, "key must be a string");
return -1;
}
#ifdef IS_PY3K
bytes = PyUnicode_AsASCIIString(py_key);
if(!bytes) {
PyErr_SetString(PyExc_TypeError, "key must be an ASCII string");
return -1;
}
key = PyBytes_AsString(bytes);
#else
key = PyString_AS_STRING(py_key);
#endif
/* Check to see whether something already exists at that key. If
there's already an object there, then I will have to remove it.
*/
py_prev = Trie_get(mp->trie, key);
if(py_prev) {
Py_DECREF(py_prev);
}
/* The client wants to delete a key from a dictionary. The Trie
API doesn't support this, so I will just overwrite it with
NULL. */
if(!py_value) {
/* If the key doesn't exist, raise a KeyError. */
if(!py_prev)
PyErr_SetString(PyExc_KeyError, key);
else {
Trie_set(mp->trie, key, NULL);
result = 0;
}
}
/* The client wants to set a key in the dictionary. */
else {
Py_INCREF(py_value);
if(Trie_set(mp->trie, key, py_value))
PyErr_SetString(PyExc_AssertionError, "error setting trie");
else
result = 0;
}
#ifdef IS_PY3K
Py_DECREF(bytes);
#endif
return result;
}
static int trie_contains(trieobject *mp, PyObject* py_key)
{
int result;
#ifdef IS_PY3K
PyObject* bytes;
#endif
const char *key;
/* Make sure key is a string. */
#ifdef IS_PY3K
if(!PyUnicode_Check(py_key)) {
#else
if(!PyString_Check(py_key)) {
#endif
PyErr_SetString(PyExc_TypeError, "key must be a string");
return -1;
}
#ifdef IS_PY3K
bytes = PyUnicode_AsASCIIString(py_key);
if(!bytes) {
PyErr_SetString(PyExc_TypeError, "key must be an ASCII string");
return -1;
}
key = PyBytes_AsString(bytes);
#else
key = PyString_AS_STRING(py_key);
#endif
result = Trie_has_key(mp->trie, key);
#ifdef IS_PY3K
Py_DECREF(bytes);
#endif
return result;
}
static char has_key__doc__[] =
"D.has_key(k) -> 1 if D has a key k, else 0";
static PyObject *
trie_has_key(trieobject *mp, PyObject *py_key)
{
int has_key = trie_contains(mp, py_key);
if (has_key==-1) return NULL;
#ifdef IS_PY3K
return PyLong_FromLong((long)has_key);
#else
return PyInt_FromLong((long)has_key);
#endif
}
int Trie_set(Trie* trie, const char *key, const void *value) {
int i;
Transition* transition=NULL;
const char *suffix=NULL;
int retval = 0;
int first, last, mid;
if(!key[0]) {
trie->value = (void *)value;
return 0;
}
/* Insert the key in alphabetical order. Do a binary search to
find the proper place. */
first = 0;
last = trie->num_transitions-1;
i = -1;
while(first <= last) {
mid = (first+last)/2;
transition = &trie->transitions[mid];
suffix = transition->suffix;
if(key[0] < suffix[0])
last = mid-1;
else if(key[0] > suffix[0])
first = mid+1;
else {
i = mid;
break;
}
}
/* If no place was found for it, then the indexes will be in the
order last,first. Place it at index first. */
if(i == -1)
i = first;
/* If nothing matches, then insert a new trie here. */
if((i >= trie->num_transitions) || (key[0] != suffix[0])) {
char *new_suffix=NULL;
Trie* newtrie=NULL;
Transition* new_transitions=NULL;
/* Create some variables for the new transition. I'm going to
allocate these first so that if I can detect memory errors
before I mess up the data structure of the transitions.
*/
if(!(new_suffix = duplicate(key)))
goto insert_memerror;
if(!(newtrie = Trie_new()))
goto insert_memerror;
/* Create some space for the next transition. Allocate some
memory and shift the old transitions over to make room for
this one.
*/
if(!(new_transitions = malloc(sizeof(Transition) *
(trie->num_transitions+1))))
goto insert_memerror;
memcpy(new_transitions, trie->transitions,
sizeof(Transition)*i);
memcpy(&new_transitions[i+1], &trie->transitions[i],
sizeof(Transition)*(trie->num_transitions-i));
free(trie->transitions);
trie->transitions = new_transitions;
new_transitions = NULL;
trie->num_transitions += 1;
/* Initialize the new transition. */
transition = &trie->transitions[i];
transition->suffix = new_suffix;
transition->next = newtrie;
transition->next->value = (void *)value;
if(0) {
insert_memerror:
if(new_transitions) free(new_transitions);
if(newtrie) free(newtrie);
if(new_suffix) free(new_suffix);
return 1;
}
}
/* There are three cases where the key and suffix share some
letters.
1. suffix is proper substring of key.
2. key is proper substring of suffix.
3. neither is proper substring of other.
For cases 2 and 3, I need to first split up the transition
based on the number of characters shared. Then, I can insert
the rest of the key into the next trie.
*/
else {
/* Count the number of characters shared between key
and suffix. */
int chars_shared = 0;
while(key[chars_shared] && key[chars_shared] == suffix[chars_shared])
chars_shared++;
/* Case 2 or 3, split this sucker! */
if(chars_shared < strlen(suffix)) {
Trie* newtrie=NULL;
char *new_suffix1=NULL, *new_suffix2=NULL;
if(!(new_suffix1 = malloc(chars_shared+1)))
goto split_memerror;
strncpy(new_suffix1, key, chars_shared);
new_suffix1[chars_shared] = 0;
if(!(new_suffix2 = duplicate(suffix+chars_shared)))
goto split_memerror;
if(!(newtrie = Trie_new()))
goto split_memerror;
if(!(newtrie->transitions = malloc(sizeof(Transition))))
goto split_memerror;
newtrie->num_transitions = 1;
newtrie->transitions[0].next = transition->next;
newtrie->transitions[0].suffix = new_suffix2;
free(transition->suffix);
transition->suffix = new_suffix1;
transition->next = newtrie;
if(0) {
split_memerror:
if(newtrie && newtrie->transitions) free(newtrie->transitions);
if(newtrie) free(newtrie);
if(new_suffix2) free(new_suffix2);
if(new_suffix1) free(new_suffix1);
return 1;
}
}
retval = Trie_set(transition->next, key+chars_shared, value);
}
return retval;
}
