Branch data Line data Source code
1 : : /*
2 : : * This file is part of the MicroPython project, http://micropython.org/
3 : : *
4 : : * The MIT License (MIT)
5 : : *
6 : : * Copyright (c) 2013-2017 Damien P. George
7 : : *
8 : : * Permission is hereby granted, free of charge, to any person obtaining a copy
9 : : * of this software and associated documentation files (the "Software"), to deal
10 : : * in the Software without restriction, including without limitation the rights
11 : : * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 : : * copies of the Software, and to permit persons to whom the Software is
13 : : * furnished to do so, subject to the following conditions:
14 : : *
15 : : * The above copyright notice and this permission notice shall be included in
16 : : * all copies or substantial portions of the Software.
17 : : *
18 : : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 : : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 : : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 : : * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 : : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 : : * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 : : * THE SOFTWARE.
25 : : */
26 : :
27 : : #include <stdbool.h>
28 : : #include <string.h>
29 : : #include <assert.h>
30 : :
31 : : #include "py/runtime.h"
32 : : #include "py/builtin.h"
33 : :
34 : : #if MICROPY_PY_BUILTINS_SET
35 : :
36 : : typedef struct _mp_obj_set_t {
37 : : mp_obj_base_t base;
38 : : mp_set_t set;
39 : : } mp_obj_set_t;
40 : :
41 : : typedef struct _mp_obj_set_it_t {
42 : : mp_obj_base_t base;
43 : : mp_fun_1_t iternext;
44 : : mp_obj_set_t *set;
45 : : size_t cur;
46 : : } mp_obj_set_it_t;
47 : :
48 : 13052 : static bool is_set_or_frozenset(mp_obj_t o) {
49 [ + + + + ]: 13052 : return mp_obj_is_type(o, &mp_type_set)
50 : : #if MICROPY_PY_BUILTINS_FROZENSET
51 [ + + + + ]: 6312 : || mp_obj_is_type(o, &mp_type_frozenset)
52 : : #endif
53 : : ;
54 : : }
55 : :
56 : : // This macro is shorthand for mp_check_self to verify the argument is a set.
57 : : #define check_set(o) mp_check_self(mp_obj_is_type(o, &mp_type_set))
58 : :
59 : : // This macro is shorthand for mp_check_self to verify the argument is a
60 : : // set or frozenset for methods that operate on both of these types.
61 : : #define check_set_or_frozenset(o) mp_check_self(is_set_or_frozenset(o))
62 : :
63 : 89 : static void set_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
64 : 89 : (void)kind;
65 : 89 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
66 : : #if MICROPY_PY_BUILTINS_FROZENSET
67 [ + - + + ]: 89 : bool is_frozen = mp_obj_is_type(self_in, &mp_type_frozenset);
68 : : #endif
69 [ + + ]: 89 : if (self->set.used == 0) {
70 : : #if MICROPY_PY_BUILTINS_FROZENSET
71 [ + + ]: 8 : if (is_frozen) {
72 : 4 : mp_print_str(print, "frozen");
73 : : }
74 : : #endif
75 : 8 : mp_print_str(print, "set()");
76 : 8 : return;
77 : : }
78 : 81 : bool first = true;
79 : : #if MICROPY_PY_BUILTINS_FROZENSET
80 [ + + ]: 81 : if (is_frozen) {
81 : 8 : mp_print_str(print, "frozenset(");
82 : : }
83 : : #endif
84 : 81 : mp_print_str(print, "{");
85 [ + + ]: 214 : for (size_t i = 0; i < self->set.alloc; i++) {
86 [ + + ]: 133 : if (mp_set_slot_is_filled(&self->set, i)) {
87 [ + + ]: 105 : if (!first) {
88 : 24 : mp_print_str(print, ", ");
89 : : }
90 : 105 : first = false;
91 : 105 : mp_obj_print_helper(print, self->set.table[i], PRINT_REPR);
92 : : }
93 : : }
94 : 81 : mp_print_str(print, "}");
95 : : #if MICROPY_PY_BUILTINS_FROZENSET
96 [ + + ]: 81 : if (is_frozen) {
97 : 8 : mp_print_str(print, ")");
98 : : }
99 : : #endif
100 : : }
101 : :
102 : 1100 : static mp_obj_t set_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
103 : 1100 : mp_arg_check_num(n_args, n_kw, 0, 1, false);
104 : :
105 [ + + ]: 1100 : switch (n_args) {
106 : 804 : case 0: {
107 : : // create a new, empty set
108 : 804 : mp_obj_set_t *set = MP_OBJ_TO_PTR(mp_obj_new_set(0, NULL));
109 : : // set actual set/frozenset type
110 : 804 : set->base.type = type;
111 : 804 : return MP_OBJ_FROM_PTR(set);
112 : : }
113 : :
114 : 296 : case 1:
115 : : default: { // can only be 0 or 1 arg
116 : : // 1 argument, an iterable from which we make a new set
117 : 296 : mp_obj_t set = mp_obj_new_set(0, NULL);
118 : 296 : mp_obj_t iterable = mp_getiter(args[0], NULL);
119 : 296 : mp_obj_t item;
120 [ + + ]: 1780 : while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
121 : 1484 : mp_obj_set_store(set, item);
122 : : }
123 : : // Set actual set/frozenset type
124 : 296 : ((mp_obj_set_t *)MP_OBJ_TO_PTR(set))->base.type = type;
125 : 296 : return set;
126 : : }
127 : : }
128 : : }
129 : :
130 : 63676 : static mp_obj_t set_it_iternext(mp_obj_t self_in) {
131 : 63676 : mp_obj_set_it_t *self = MP_OBJ_TO_PTR(self_in);
132 : 63676 : size_t max = self->set->set.alloc;
133 : 63676 : mp_set_t *set = &self->set->set;
134 : :
135 [ + + ]: 72928 : for (size_t i = self->cur; i < max; i++) {
136 [ + + ]: 49494 : if (mp_set_slot_is_filled(set, i)) {
137 : 40242 : self->cur = i + 1;
138 : 40242 : return set->table[i];
139 : : }
140 : : }
141 : :
142 : : return MP_OBJ_STOP_ITERATION;
143 : : }
144 : :
145 : 25014 : static mp_obj_t set_getiter(mp_obj_t set_in, mp_obj_iter_buf_t *iter_buf) {
146 : 25014 : assert(sizeof(mp_obj_set_it_t) <= sizeof(mp_obj_iter_buf_t));
147 : 25014 : mp_obj_set_it_t *o = (mp_obj_set_it_t *)iter_buf;
148 : 25014 : o->base.type = &mp_type_polymorph_iter;
149 : 25014 : o->iternext = set_it_iternext;
150 : 25014 : o->set = (mp_obj_set_t *)MP_OBJ_TO_PTR(set_in);
151 : 25014 : o->cur = 0;
152 : 25014 : return MP_OBJ_FROM_PTR(o);
153 : : }
154 : :
155 : : /******************************************************************************/
156 : : /* set methods */
157 : :
158 : 10896 : static mp_obj_t set_add(mp_obj_t self_in, mp_obj_t item) {
159 : 10896 : check_set(self_in);
160 : 10896 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
161 : 10896 : mp_set_lookup(&self->set, item, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
162 : 10896 : return mp_const_none;
163 : : }
164 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_add_obj, set_add);
165 : :
166 : 128 : static mp_obj_t set_clear(mp_obj_t self_in) {
167 : 128 : check_set(self_in);
168 : 128 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
169 : 128 : mp_set_clear(&self->set);
170 : 128 : return mp_const_none;
171 : : }
172 : : static MP_DEFINE_CONST_FUN_OBJ_1(set_clear_obj, set_clear);
173 : :
174 : 4472 : static mp_obj_t set_copy(mp_obj_t self_in) {
175 : 4472 : check_set_or_frozenset(self_in);
176 : 4472 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
177 : 4472 : mp_obj_set_t *other = mp_obj_malloc(mp_obj_set_t, self->base.type);
178 : 4468 : mp_set_init(&other->set, self->set.alloc);
179 : 4468 : other->set.used = self->set.used;
180 : 4468 : memcpy(other->set.table, self->set.table, self->set.alloc * sizeof(mp_obj_t));
181 : 4468 : return MP_OBJ_FROM_PTR(other);
182 : : }
183 : : static MP_DEFINE_CONST_FUN_OBJ_1(set_copy_obj, set_copy);
184 : :
185 : 4 : static mp_obj_t set_discard(mp_obj_t self_in, mp_obj_t item) {
186 : 4 : check_set(self_in);
187 : 4 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
188 : 4 : mp_set_lookup(&self->set, item, MP_MAP_LOOKUP_REMOVE_IF_FOUND);
189 : 4 : return mp_const_none;
190 : : }
191 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_discard_obj, set_discard);
192 : :
193 : 1076 : static mp_obj_t set_diff_int(size_t n_args, const mp_obj_t *args, bool update) {
194 : 1076 : mp_obj_t self;
195 [ + + ]: 1076 : if (update) {
196 : 276 : check_set(args[0]);
197 : 276 : self = args[0];
198 : : } else {
199 : 800 : self = set_copy(args[0]);
200 : : }
201 : :
202 [ + + ]: 2168 : for (size_t i = 1; i < n_args; i++) {
203 : 1092 : mp_obj_t other = args[i];
204 [ + + ]: 1092 : if (self == other) {
205 : 4 : set_clear(self);
206 : : } else {
207 : 1088 : mp_set_t *self_set = &((mp_obj_set_t *)MP_OBJ_TO_PTR(self))->set;
208 : 1088 : mp_obj_t iter = mp_getiter(other, NULL);
209 : 1088 : mp_obj_t next;
210 [ + + ]: 2844 : while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
211 : 1756 : mp_set_lookup(self_set, next, MP_MAP_LOOKUP_REMOVE_IF_FOUND);
212 : : }
213 : : }
214 : : }
215 : :
216 : 1076 : return self;
217 : : }
218 : :
219 : 544 : static mp_obj_t set_diff(size_t n_args, const mp_obj_t *args) {
220 : 544 : return set_diff_int(n_args, args, false);
221 : : }
222 : : static MP_DEFINE_CONST_FUN_OBJ_VAR(set_diff_obj, 1, set_diff);
223 : :
224 : 16 : static mp_obj_t set_diff_update(size_t n_args, const mp_obj_t *args) {
225 : 16 : set_diff_int(n_args, args, true);
226 : 16 : return mp_const_none;
227 : : }
228 : : static MP_DEFINE_CONST_FUN_OBJ_VAR(set_diff_update_obj, 1, set_diff_update);
229 : :
230 : 1040 : static mp_obj_t set_intersect_int(mp_obj_t self_in, mp_obj_t other, bool update) {
231 : 1040 : if (update) {
232 : 1040 : check_set(self_in);
233 : : } else {
234 : 1040 : check_set_or_frozenset(self_in);
235 : : }
236 : :
237 [ + + ]: 1040 : if (self_in == other) {
238 [ + - ]: 64 : return update ? mp_const_none : set_copy(self_in);
239 : : }
240 : :
241 : 976 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
242 : 976 : mp_obj_set_t *out = MP_OBJ_TO_PTR(mp_obj_new_set(0, NULL));
243 : :
244 : 976 : mp_obj_t iter = mp_getiter(other, NULL);
245 : 976 : mp_obj_t next;
246 [ + + ]: 3540 : while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
247 [ + + ]: 1588 : if (mp_set_lookup(&self->set, next, MP_MAP_LOOKUP)) {
248 : 544 : set_add(MP_OBJ_FROM_PTR(out), next);
249 : : }
250 : : }
251 : :
252 [ + + ]: 976 : if (update) {
253 : 264 : m_del(mp_obj_t, self->set.table, self->set.alloc);
254 : 264 : self->set.alloc = out->set.alloc;
255 : 264 : self->set.used = out->set.used;
256 : 264 : self->set.table = out->set.table;
257 : : }
258 : :
259 : 264 : return update ? mp_const_none : MP_OBJ_FROM_PTR(out);
260 : : }
261 : :
262 : 520 : static mp_obj_t set_intersect(mp_obj_t self_in, mp_obj_t other) {
263 : 520 : return set_intersect_int(self_in, other, false);
264 : : }
265 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_intersect_obj, set_intersect);
266 : :
267 : 4 : static mp_obj_t set_intersect_update(mp_obj_t self_in, mp_obj_t other) {
268 : 4 : return set_intersect_int(self_in, other, true);
269 : : }
270 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_intersect_update_obj, set_intersect_update);
271 : :
272 : 20 : static mp_obj_t set_isdisjoint(mp_obj_t self_in, mp_obj_t other) {
273 : 20 : check_set_or_frozenset(self_in);
274 : 20 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
275 : :
276 : 20 : mp_obj_iter_buf_t iter_buf;
277 : 20 : mp_obj_t iter = mp_getiter(other, &iter_buf);
278 : 20 : mp_obj_t next;
279 [ + + ]: 48 : while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
280 [ + + ]: 40 : if (mp_set_lookup(&self->set, next, MP_MAP_LOOKUP)) {
281 : : return mp_const_false;
282 : : }
283 : : }
284 : : return mp_const_true;
285 : : }
286 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_isdisjoint_obj, set_isdisjoint);
287 : :
288 : 2534 : static mp_obj_t set_issubset_internal(mp_obj_t self_in, mp_obj_t other_in, bool proper) {
289 : 2534 : mp_obj_set_t *self;
290 : 2534 : bool cleanup_self = false;
291 [ + + ]: 2534 : if (is_set_or_frozenset(self_in)) {
292 : : self = MP_OBJ_TO_PTR(self_in);
293 : : } else {
294 : 60 : self = MP_OBJ_TO_PTR(set_make_new(&mp_type_set, 1, 0, &self_in));
295 : 60 : cleanup_self = true;
296 : : }
297 : :
298 : 2534 : mp_obj_set_t *other;
299 : 2534 : bool cleanup_other = false;
300 [ + + ]: 2534 : if (is_set_or_frozenset(other_in)) {
301 : : other = MP_OBJ_TO_PTR(other_in);
302 : : } else {
303 : 60 : other = MP_OBJ_TO_PTR(set_make_new(&mp_type_set, 1, 0, &other_in));
304 : 60 : cleanup_other = true;
305 : : }
306 : 2534 : mp_obj_t out = mp_const_true;
307 [ + + + + ]: 2534 : if (proper && self->set.used == other->set.used) {
308 : : out = mp_const_false;
309 : : } else {
310 : 2246 : mp_obj_iter_buf_t iter_buf;
311 : 2246 : mp_obj_t iter = set_getiter(MP_OBJ_FROM_PTR(self), &iter_buf);
312 : 2246 : mp_obj_t next;
313 [ + + ]: 3144 : while ((next = set_it_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
314 [ + + ]: 2470 : if (!mp_set_lookup(&other->set, next, MP_MAP_LOOKUP)) {
315 : : out = mp_const_false;
316 : : break;
317 : : }
318 : : }
319 : : }
320 : : // TODO: Should free objects altogether
321 [ + + ]: 2534 : if (cleanup_self) {
322 : 60 : set_clear(MP_OBJ_FROM_PTR(self));
323 : : }
324 [ + + ]: 2534 : if (cleanup_other) {
325 : 60 : set_clear(MP_OBJ_FROM_PTR(other));
326 : : }
327 : 2534 : return out;
328 : : }
329 : :
330 : 838 : static mp_obj_t set_issubset(mp_obj_t self_in, mp_obj_t other_in) {
331 : 838 : return set_issubset_internal(self_in, other_in, false);
332 : : }
333 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_issubset_obj, set_issubset);
334 : :
335 : 512 : static mp_obj_t set_issubset_proper(mp_obj_t self_in, mp_obj_t other_in) {
336 : 512 : return set_issubset_internal(self_in, other_in, true);
337 : : }
338 : :
339 : 672 : static mp_obj_t set_issuperset(mp_obj_t self_in, mp_obj_t other_in) {
340 : 672 : return set_issubset_internal(other_in, self_in, false);
341 : : }
342 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_issuperset_obj, set_issuperset);
343 : :
344 : 512 : static mp_obj_t set_issuperset_proper(mp_obj_t self_in, mp_obj_t other_in) {
345 : 512 : return set_issubset_internal(other_in, self_in, true);
346 : : }
347 : :
348 : 902 : static mp_obj_t set_equal(mp_obj_t self_in, mp_obj_t other_in) {
349 [ - + ]: 902 : assert(is_set_or_frozenset(other_in));
350 : 902 : check_set_or_frozenset(self_in);
351 : 902 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
352 : 902 : mp_obj_set_t *other = MP_OBJ_TO_PTR(other_in);
353 [ + + ]: 902 : if (self->set.used != other->set.used) {
354 : : return mp_const_false;
355 : : }
356 : 166 : return set_issubset(self_in, other_in);
357 : : }
358 : :
359 : 52 : static mp_obj_t set_pop(mp_obj_t self_in) {
360 : 52 : check_set(self_in);
361 : 52 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
362 : 52 : mp_obj_t obj = mp_set_remove_first(&self->set);
363 [ + + ]: 52 : if (obj == MP_OBJ_NULL) {
364 : 4 : mp_raise_msg(&mp_type_KeyError, MP_ERROR_TEXT("pop from an empty set"));
365 : : }
366 : 48 : return obj;
367 : : }
368 : : static MP_DEFINE_CONST_FUN_OBJ_1(set_pop_obj, set_pop);
369 : :
370 : 768 : static mp_obj_t set_remove(mp_obj_t self_in, mp_obj_t item) {
371 : 768 : check_set(self_in);
372 : 768 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
373 [ + + ]: 768 : if (mp_set_lookup(&self->set, item, MP_MAP_LOOKUP_REMOVE_IF_FOUND) == MP_OBJ_NULL) {
374 : 4 : mp_raise_type_arg(&mp_type_KeyError, item);
375 : : }
376 : 764 : return mp_const_none;
377 : : }
378 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_remove_obj, set_remove);
379 : :
380 : 1040 : static mp_obj_t set_symmetric_difference_update(mp_obj_t self_in, mp_obj_t other_in) {
381 : 1040 : check_set_or_frozenset(self_in); // can be frozenset due to call from set_symmetric_difference
382 : 1040 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
383 : 1040 : mp_obj_t iter = mp_getiter(other_in, NULL);
384 : 1040 : mp_obj_t next;
385 [ + + ]: 2736 : while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
386 : 1696 : mp_set_lookup(&self->set, next, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND_OR_REMOVE_IF_FOUND);
387 : : }
388 : 1040 : return mp_const_none;
389 : : }
390 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_symmetric_difference_update_obj, set_symmetric_difference_update);
391 : :
392 : 776 : static mp_obj_t set_symmetric_difference(mp_obj_t self_in, mp_obj_t other_in) {
393 : 776 : mp_obj_t self_out = set_copy(self_in);
394 : 776 : set_symmetric_difference_update(self_out, other_in);
395 : 776 : return self_out;
396 : : }
397 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_symmetric_difference_obj, set_symmetric_difference);
398 : :
399 : 1044 : static void set_update_int(mp_obj_set_t *self, mp_obj_t other_in) {
400 : 1044 : mp_obj_t iter = mp_getiter(other_in, NULL);
401 : 1044 : mp_obj_t next;
402 [ + + ]: 2744 : while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
403 : 1700 : mp_set_lookup(&self->set, next, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
404 : : }
405 : 1044 : }
406 : :
407 : 272 : static mp_obj_t set_update(size_t n_args, const mp_obj_t *args) {
408 : 272 : check_set(args[0]);
409 [ + + ]: 544 : for (size_t i = 1; i < n_args; i++) {
410 : 272 : set_update_int(MP_OBJ_TO_PTR(args[0]), args[i]);
411 : : }
412 : :
413 : 272 : return mp_const_none;
414 : : }
415 : : static MP_DEFINE_CONST_FUN_OBJ_VAR(set_update_obj, 1, set_update);
416 : :
417 : 772 : static mp_obj_t set_union(mp_obj_t self_in, mp_obj_t other_in) {
418 : 772 : check_set_or_frozenset(self_in);
419 : 772 : mp_obj_t self = set_copy(self_in);
420 : 772 : set_update_int(MP_OBJ_TO_PTR(self), other_in);
421 : 772 : return self;
422 : : }
423 : : static MP_DEFINE_CONST_FUN_OBJ_2(set_union_obj, set_union);
424 : :
425 : 1634 : static mp_obj_t set_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
426 : 1634 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
427 [ + + + - ]: 1634 : switch (op) {
428 : 56 : case MP_UNARY_OP_BOOL:
429 [ + + ]: 56 : return mp_obj_new_bool(self->set.used != 0);
430 : 1566 : case MP_UNARY_OP_LEN:
431 : 1566 : return MP_OBJ_NEW_SMALL_INT(self->set.used);
432 : : #if MICROPY_PY_BUILTINS_FROZENSET
433 : : case MP_UNARY_OP_HASH:
434 [ + - + + ]: 12 : if (mp_obj_is_type(self_in, &mp_type_frozenset)) {
435 : : // start hash with unique value
436 : 4 : mp_int_t hash = (mp_int_t)(uintptr_t)&mp_type_frozenset;
437 : 4 : size_t max = self->set.alloc;
438 : 4 : mp_set_t *set = &self->set;
439 : :
440 [ + + ]: 12 : for (size_t i = 0; i < max; i++) {
441 [ + + ]: 8 : if (mp_set_slot_is_filled(set, i)) {
442 : 4 : hash += MP_OBJ_SMALL_INT_VALUE(mp_unary_op(MP_UNARY_OP_HASH, set->table[i]));
443 : : }
444 : : }
445 : 4 : return MP_OBJ_NEW_SMALL_INT(hash);
446 : : }
447 : : MP_FALLTHROUGH
448 : : #endif
449 : : default:
450 : : return MP_OBJ_NULL; // op not supported
451 : : }
452 : : }
453 : :
454 : 17012 : static mp_obj_t set_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
455 : 17012 : mp_obj_t args[] = {lhs, rhs};
456 : : #if MICROPY_PY_BUILTINS_FROZENSET
457 [ + - + + ]: 17012 : bool update = mp_obj_is_type(lhs, &mp_type_set);
458 : : #else
459 : : bool update = true;
460 : : #endif
461 [ + + + + ]: 17012 : if (op != MP_BINARY_OP_CONTAINS && !is_set_or_frozenset(rhs)) {
462 : : // For all ops except containment the RHS must be a set/frozenset
463 : : return MP_OBJ_NULL;
464 : : }
465 [ + + + + : 7070 : switch (op) {
+ + + + +
+ + + + -
+ ]
466 : 512 : case MP_BINARY_OP_OR:
467 : 512 : return set_union(lhs, rhs);
468 : 512 : case MP_BINARY_OP_XOR:
469 : 512 : return set_symmetric_difference(lhs, rhs);
470 : 512 : case MP_BINARY_OP_AND:
471 : 512 : return set_intersect(lhs, rhs);
472 : 512 : case MP_BINARY_OP_SUBTRACT:
473 : 512 : return set_diff(2, args);
474 : 516 : case MP_BINARY_OP_INPLACE_OR:
475 [ + + ]: 516 : if (update) {
476 : 260 : set_update(2, args);
477 : 260 : return lhs;
478 : : } else {
479 : 256 : return set_union(lhs, rhs);
480 : : }
481 : 516 : case MP_BINARY_OP_INPLACE_XOR:
482 [ + + ]: 516 : if (update) {
483 : 260 : set_symmetric_difference_update(lhs, rhs);
484 : 260 : return lhs;
485 : : } else {
486 : 256 : return set_symmetric_difference(lhs, rhs);
487 : : }
488 : 516 : case MP_BINARY_OP_INPLACE_AND:
489 : 516 : rhs = set_intersect_int(lhs, rhs, update);
490 [ + + ]: 516 : if (update) {
491 : : return lhs;
492 : : } else {
493 : 256 : return rhs;
494 : : }
495 : 516 : case MP_BINARY_OP_INPLACE_SUBTRACT:
496 : 516 : return set_diff_int(2, args, update);
497 : 512 : case MP_BINARY_OP_LESS:
498 : 512 : return set_issubset_proper(lhs, rhs);
499 : 512 : case MP_BINARY_OP_MORE:
500 : 512 : return set_issuperset_proper(lhs, rhs);
501 : 902 : case MP_BINARY_OP_EQUAL:
502 : 902 : return set_equal(lhs, rhs);
503 : 512 : case MP_BINARY_OP_LESS_EQUAL:
504 : 512 : return set_issubset(lhs, rhs);
505 : 512 : case MP_BINARY_OP_MORE_EQUAL:
506 : 512 : return set_issuperset(lhs, rhs);
507 : 9930 : case MP_BINARY_OP_CONTAINS: {
508 : 9930 : mp_obj_set_t *o = MP_OBJ_TO_PTR(lhs);
509 : 9930 : mp_obj_t elem = mp_set_lookup(&o->set, rhs, MP_MAP_LOOKUP);
510 [ + + ]: 9930 : return mp_obj_new_bool(elem != MP_OBJ_NULL);
511 : : }
512 : : default:
513 : : return MP_OBJ_NULL; // op not supported
514 : : }
515 : : }
516 : :
517 : : /******************************************************************************/
518 : : /* set constructors & public C API */
519 : :
520 : : static const mp_rom_map_elem_t set_locals_dict_table[] = {
521 : : { MP_ROM_QSTR(MP_QSTR_add), MP_ROM_PTR(&set_add_obj) },
522 : : { MP_ROM_QSTR(MP_QSTR_clear), MP_ROM_PTR(&set_clear_obj) },
523 : : { MP_ROM_QSTR(MP_QSTR_copy), MP_ROM_PTR(&set_copy_obj) },
524 : : { MP_ROM_QSTR(MP_QSTR_discard), MP_ROM_PTR(&set_discard_obj) },
525 : : { MP_ROM_QSTR(MP_QSTR_difference), MP_ROM_PTR(&set_diff_obj) },
526 : : { MP_ROM_QSTR(MP_QSTR_difference_update), MP_ROM_PTR(&set_diff_update_obj) },
527 : : { MP_ROM_QSTR(MP_QSTR_intersection), MP_ROM_PTR(&set_intersect_obj) },
528 : : { MP_ROM_QSTR(MP_QSTR_intersection_update), MP_ROM_PTR(&set_intersect_update_obj) },
529 : : { MP_ROM_QSTR(MP_QSTR_isdisjoint), MP_ROM_PTR(&set_isdisjoint_obj) },
530 : : { MP_ROM_QSTR(MP_QSTR_issubset), MP_ROM_PTR(&set_issubset_obj) },
531 : : { MP_ROM_QSTR(MP_QSTR_issuperset), MP_ROM_PTR(&set_issuperset_obj) },
532 : : { MP_ROM_QSTR(MP_QSTR_pop), MP_ROM_PTR(&set_pop_obj) },
533 : : { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&set_remove_obj) },
534 : : { MP_ROM_QSTR(MP_QSTR_symmetric_difference), MP_ROM_PTR(&set_symmetric_difference_obj) },
535 : : { MP_ROM_QSTR(MP_QSTR_symmetric_difference_update), MP_ROM_PTR(&set_symmetric_difference_update_obj) },
536 : : { MP_ROM_QSTR(MP_QSTR_union), MP_ROM_PTR(&set_union_obj) },
537 : : { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&set_update_obj) },
538 : : { MP_ROM_QSTR(MP_QSTR___contains__), MP_ROM_PTR(&mp_op_contains_obj) },
539 : : };
540 : : static MP_DEFINE_CONST_DICT(set_locals_dict, set_locals_dict_table);
541 : :
542 : : MP_DEFINE_CONST_OBJ_TYPE(
543 : : mp_type_set,
544 : : MP_QSTR_set,
545 : : MP_TYPE_FLAG_ITER_IS_GETITER,
546 : : make_new, set_make_new,
547 : : print, set_print,
548 : : unary_op, set_unary_op,
549 : : binary_op, set_binary_op,
550 : : iter, set_getiter,
551 : : locals_dict, &set_locals_dict
552 : : );
553 : :
554 : : #if MICROPY_PY_BUILTINS_FROZENSET
555 : : static const mp_rom_map_elem_t frozenset_locals_dict_table[] = {
556 : : { MP_ROM_QSTR(MP_QSTR_copy), MP_ROM_PTR(&set_copy_obj) },
557 : : { MP_ROM_QSTR(MP_QSTR_difference), MP_ROM_PTR(&set_diff_obj) },
558 : : { MP_ROM_QSTR(MP_QSTR_intersection), MP_ROM_PTR(&set_intersect_obj) },
559 : : { MP_ROM_QSTR(MP_QSTR_isdisjoint), MP_ROM_PTR(&set_isdisjoint_obj) },
560 : : { MP_ROM_QSTR(MP_QSTR_issubset), MP_ROM_PTR(&set_issubset_obj) },
561 : : { MP_ROM_QSTR(MP_QSTR_issuperset), MP_ROM_PTR(&set_issuperset_obj) },
562 : : { MP_ROM_QSTR(MP_QSTR_symmetric_difference), MP_ROM_PTR(&set_symmetric_difference_obj) },
563 : : { MP_ROM_QSTR(MP_QSTR_union), MP_ROM_PTR(&set_union_obj) },
564 : : { MP_ROM_QSTR(MP_QSTR___contains__), MP_ROM_PTR(&mp_op_contains_obj) },
565 : : };
566 : : static MP_DEFINE_CONST_DICT(frozenset_locals_dict, frozenset_locals_dict_table);
567 : :
568 : : MP_DEFINE_CONST_OBJ_TYPE(
569 : : mp_type_frozenset,
570 : : MP_QSTR_frozenset,
571 : : MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE | MP_TYPE_FLAG_ITER_IS_GETITER,
572 : : make_new, set_make_new,
573 : : print, set_print,
574 : : unary_op, set_unary_op,
575 : : binary_op, set_binary_op,
576 : : iter, set_getiter,
577 : : locals_dict, &frozenset_locals_dict
578 : : );
579 : : #endif
580 : :
581 : 2381 : mp_obj_t mp_obj_new_set(size_t n_args, mp_obj_t *items) {
582 : 2381 : mp_obj_set_t *o = mp_obj_malloc(mp_obj_set_t, &mp_type_set);
583 : 2377 : mp_set_init(&o->set, n_args);
584 [ + + ]: 2968 : for (size_t i = 0; i < n_args; i++) {
585 : 591 : mp_set_lookup(&o->set, items[i], MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
586 : : }
587 : 2377 : return MP_OBJ_FROM_PTR(o);
588 : : }
589 : :
590 : 1504 : void mp_obj_set_store(mp_obj_t self_in, mp_obj_t item) {
591 : 1504 : mp_check_self(mp_obj_is_type(self_in, &mp_type_set));
592 : 1504 : mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
593 : 1504 : mp_set_lookup(&self->set, item, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
594 : 1504 : }
595 : :
596 : : #endif // MICROPY_PY_BUILTINS_SET
|
