objdict.c 4.27 KB
Newer Older
1
2
3
4
5
6
7
8
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>

#include "nlr.h"
#include "misc.h"
#include "mpconfig.h"
9
#include "mpqstr.h"
10
11
12
13
14
15
16
17
18
19
#include "obj.h"
#include "runtime0.h"
#include "runtime.h"
#include "map.h"

typedef struct _mp_obj_dict_t {
    mp_obj_base_t base;
    mp_map_t map;
} mp_obj_dict_t;

John R. Lenton's avatar
John R. Lenton committed
20
21
22
static mp_obj_t mp_obj_new_dict_iterator(mp_obj_dict_t *dict, int cur);
static mp_map_elem_t *dict_it_iternext_elem(mp_obj_t self_in);

23
static void dict_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in) {
24
25
26
    mp_obj_dict_t *self = self_in;
    bool first = true;
    print(env, "{");
John R. Lenton's avatar
John R. Lenton committed
27
28
29
30
31
    mp_obj_t *dict_iter = mp_obj_new_dict_iterator(self, 0);
    mp_map_elem_t *next = NULL;
    while ((next = dict_it_iternext_elem(dict_iter)) != NULL) {
        if (!first) {
            print(env, ", ");
32
        }
John R. Lenton's avatar
John R. Lenton committed
33
34
35
36
        first = false;
        mp_obj_print_helper(print, env, next->key);
        print(env, ": ");
        mp_obj_print_helper(print, env, next->value);
37
38
39
40
    }
    print(env, "}");
}

41
42
43
44
45
46
47
// args are reverse in the array
static mp_obj_t dict_make_new(mp_obj_t type_in, int n_args, const mp_obj_t *args) {
    // TODO create from an iterable!
    return rt_build_map(0);
}

static mp_obj_t dict_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
48
49
50
51
52
53
54
    mp_obj_dict_t *o = lhs_in;
    switch (op) {
        case RT_BINARY_OP_SUBSCR:
        {
            // dict load
            mp_map_elem_t *elem = mp_map_lookup_helper(&o->map, rhs_in, false);
            if (elem == NULL) {
55
                nlr_jump(mp_obj_new_exception_msg(MP_QSTR_KeyError, "<value>"));
56
57
58
59
60
61
62
63
64
65
            } else {
                return elem->value;
            }
        }
        default:
            // op not supported
            return NULL;
    }
}

John R. Lenton's avatar
John R. Lenton committed
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

/******************************************************************************/
/* dict iterator                                                              */

typedef struct _mp_obj_dict_it_t {
    mp_obj_base_t base;
    mp_obj_dict_t *dict;
    machine_uint_t cur;
} mp_obj_dict_it_t;

static mp_map_elem_t *dict_it_iternext_elem(mp_obj_t self_in) {
    mp_obj_dict_it_t *self = self_in;
    machine_uint_t max = self->dict->map.alloc;
    mp_map_elem_t *table = self->dict->map.table;

    for (int i = self->cur; i < max; i++) {
        if (table[i].key != NULL) {
            self->cur = i + 1;
            return &(table[i]);
        }
    }

    return NULL;
}

mp_obj_t dict_it_iternext(mp_obj_t self_in) {
    mp_map_elem_t *next = dict_it_iternext_elem(self_in);

    if (next != NULL) {
        return next->key;
    } else {
        return mp_const_stop_iteration;
    }
}

static const mp_obj_type_t dict_it_type = {
    { &mp_const_type },
    "dict_iterator",
    .iternext = dict_it_iternext,
    .methods = { { NULL, NULL }, },
};

static mp_obj_t mp_obj_new_dict_iterator(mp_obj_dict_t *dict, int cur) {
    mp_obj_dict_it_t *o = m_new_obj(mp_obj_dict_it_t);
    o->base.type = &dict_it_type;
    o->dict = dict;
    o->cur = cur;
    return o;
}

static mp_obj_t dict_getiter(mp_obj_t o_in) {
    return mp_obj_new_dict_iterator(o_in, 0);
}

/******************************************************************************/
/* dict methods                                                               */

/******************************************************************************/
/* dict constructors & etc                                                    */

126
127
128
const mp_obj_type_t dict_type = {
    { &mp_const_type },
    "dict",
129
130
131
    .print = dict_print,
    .make_new = dict_make_new,
    .binary_op = dict_binary_op,
John R. Lenton's avatar
John R. Lenton committed
132
    .getiter = dict_getiter,
133
    .methods = {{NULL, NULL},},
134
135
136
137
138
139
140
141
};

mp_obj_t mp_obj_new_dict(int n_args) {
    mp_obj_dict_t *o = m_new_obj(mp_obj_dict_t);
    o->base.type = &dict_type;
    mp_map_init(&o->map, MP_MAP_OBJ, n_args);
    return o;
}
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

uint mp_obj_dict_len(mp_obj_t self_in) {
    mp_obj_dict_t *self = self_in;
    uint len = 0;
    for (int i = 0; i < self->map.alloc; i++) {
        if (self->map.table[i].key != NULL) {
            len += 1;
        }
    }
    return len;
}

mp_obj_t mp_obj_dict_store(mp_obj_t self_in, mp_obj_t key, mp_obj_t value) {
    assert(MP_OBJ_IS_TYPE(self_in, &dict_type));
    mp_obj_dict_t *self = self_in;
    mp_map_lookup_helper(&self->map, key, true)->value = value;
    return self_in;
}