LCOV - code coverage report
Current view: top level - py - objtuple.c (source / functions) Hit Total Coverage
Test: unix_coverage_v1.19.1-724-gfb7d21153.info Lines: 127 127 100.0 %
Date: 2022-12-01 09:37:31 Functions: 13 13 100.0 %
Branches: 67 78 85.9 %

           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, 2014 Damien P. George
       7                 :            :  * Copyright (c) 2014-2017 Paul Sokolovsky
       8                 :            :  *
       9                 :            :  * Permission is hereby granted, free of charge, to any person obtaining a copy
      10                 :            :  * of this software and associated documentation files (the "Software"), to deal
      11                 :            :  * in the Software without restriction, including without limitation the rights
      12                 :            :  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      13                 :            :  * copies of the Software, and to permit persons to whom the Software is
      14                 :            :  * furnished to do so, subject to the following conditions:
      15                 :            :  *
      16                 :            :  * The above copyright notice and this permission notice shall be included in
      17                 :            :  * all copies or substantial portions of the Software.
      18                 :            :  *
      19                 :            :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      20                 :            :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      21                 :            :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      22                 :            :  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      23                 :            :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      24                 :            :  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
      25                 :            :  * THE SOFTWARE.
      26                 :            :  */
      27                 :            : 
      28                 :            : #include <string.h>
      29                 :            : #include <assert.h>
      30                 :            : 
      31                 :            : #include "py/objtuple.h"
      32                 :            : #include "py/runtime.h"
      33                 :            : 
      34                 :            : // type check is done on getiter method to allow tuple, namedtuple, attrtuple
      35                 :            : #define mp_obj_is_tuple_compatible(o) (MP_OBJ_TYPE_GET_SLOT_OR_NULL(mp_obj_get_type(o), iter) == mp_obj_tuple_getiter)
      36                 :            : 
      37                 :            : /******************************************************************************/
      38                 :            : /* tuple                                                                      */
      39                 :            : 
      40                 :       2667 : void mp_obj_tuple_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
      41                 :       2667 :     mp_obj_tuple_t *o = MP_OBJ_TO_PTR(o_in);
      42                 :       2667 :     const char *item_separator = ", ";
      43         [ +  + ]:       2667 :     if (MICROPY_PY_UJSON && kind == PRINT_JSON) {
      44                 :        112 :         mp_print_str(print, "[");
      45                 :            :         #if MICROPY_PY_UJSON_SEPARATORS
      46                 :        112 :         item_separator = MP_PRINT_GET_EXT(print)->item_separator;
      47                 :            :         #endif
      48                 :            :     } else {
      49                 :       2555 :         mp_print_str(print, "(");
      50                 :       2555 :         kind = PRINT_REPR;
      51                 :            :     }
      52         [ +  + ]:       8621 :     for (size_t i = 0; i < o->len; i++) {
      53         [ +  + ]:       5954 :         if (i > 0) {
      54                 :       3544 :             mp_print_str(print, item_separator);
      55                 :            :         }
      56                 :       5954 :         mp_obj_print_helper(print, o->items[i], kind);
      57                 :            :     }
      58         [ +  + ]:       2667 :     if (MICROPY_PY_UJSON && kind == PRINT_JSON) {
      59                 :        112 :         mp_print_str(print, "]");
      60                 :            :     } else {
      61         [ +  + ]:       2555 :         if (o->len == 1) {
      62                 :        442 :             mp_print_str(print, ",");
      63                 :            :         }
      64                 :       2555 :         mp_print_str(print, ")");
      65                 :            :     }
      66                 :       2667 : }
      67                 :            : 
      68                 :        144 : STATIC mp_obj_t mp_obj_tuple_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
      69                 :        144 :     (void)type_in;
      70                 :            : 
      71                 :        144 :     mp_arg_check_num(n_args, n_kw, 0, 1, false);
      72                 :            : 
      73         [ +  + ]:        144 :     switch (n_args) {
      74                 :            :         case 0:
      75                 :            :             // return a empty tuple
      76                 :            :             return mp_const_empty_tuple;
      77                 :            : 
      78                 :            :         case 1:
      79                 :            :         default: {
      80                 :            :             // 1 argument, an iterable from which we make a new tuple
      81   [ +  -  +  + ]:        128 :             if (mp_obj_is_type(args[0], &mp_type_tuple)) {
      82                 :            :                 return args[0];
      83                 :            :             }
      84                 :            : 
      85                 :            :             // TODO optimise for cases where we know the length of the iterator
      86                 :            : 
      87                 :        124 :             size_t alloc = 4;
      88                 :        124 :             size_t len = 0;
      89                 :        124 :             mp_obj_t *items = m_new(mp_obj_t, alloc);
      90                 :            : 
      91                 :        124 :             mp_obj_t iterable = mp_getiter(args[0], NULL);
      92                 :        124 :             mp_obj_t item;
      93         [ +  + ]:        480 :             while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
      94         [ +  + ]:        356 :                 if (len >= alloc) {
      95                 :         16 :                     items = m_renew(mp_obj_t, items, alloc, alloc * 2);
      96                 :         16 :                     alloc *= 2;
      97                 :            :                 }
      98                 :        356 :                 items[len++] = item;
      99                 :            :             }
     100                 :            : 
     101                 :        112 :             mp_obj_t tuple = mp_obj_new_tuple(len, items);
     102                 :        112 :             m_del(mp_obj_t, items, alloc);
     103                 :            : 
     104                 :        112 :             return tuple;
     105                 :            :         }
     106                 :            :     }
     107                 :            : }
     108                 :            : 
     109                 :            : // Don't pass MP_BINARY_OP_NOT_EQUAL here
     110                 :        626 : STATIC mp_obj_t tuple_cmp_helper(mp_uint_t op, mp_obj_t self_in, mp_obj_t another_in) {
     111                 :        626 :     mp_check_self(mp_obj_is_tuple_compatible(self_in));
     112                 :        626 :     const mp_obj_type_t *another_type = mp_obj_get_type(another_in);
     113                 :        626 :     mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
     114   [ +  -  +  + ]:        626 :     if (MP_OBJ_TYPE_GET_SLOT_OR_NULL(another_type, iter) != mp_obj_tuple_getiter) {
     115                 :            :         // Slow path for user subclasses
     116                 :         12 :         another_in = mp_obj_cast_to_native_base(another_in, MP_OBJ_FROM_PTR(&mp_type_tuple));
     117         [ +  + ]:         12 :         if (another_in == MP_OBJ_NULL) {
     118                 :            :             return MP_OBJ_NULL;
     119                 :            :         }
     120                 :            :     }
     121                 :        622 :     mp_obj_tuple_t *another = MP_OBJ_TO_PTR(another_in);
     122                 :            : 
     123         [ +  + ]:        622 :     return mp_obj_new_bool(mp_seq_cmp_objs(op, self->items, self->len, another->items, another->len));
     124                 :            : }
     125                 :            : 
     126                 :       4893 : mp_obj_t mp_obj_tuple_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     127                 :       4893 :     mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
     128   [ +  +  +  + ]:       4893 :     switch (op) {
     129                 :        270 :         case MP_UNARY_OP_BOOL:
     130         [ +  + ]:        270 :             return mp_obj_new_bool(self->len != 0);
     131                 :        232 :         case MP_UNARY_OP_HASH: {
     132                 :            :             // start hash with pointer to empty tuple, to make it fairly unique
     133                 :        232 :             mp_int_t hash = (mp_int_t)mp_const_empty_tuple;
     134         [ +  + ]:       2252 :             for (size_t i = 0; i < self->len; i++) {
     135                 :       2020 :                 hash += MP_OBJ_SMALL_INT_VALUE(mp_unary_op(MP_UNARY_OP_HASH, self->items[i]));
     136                 :            :             }
     137                 :        232 :             return MP_OBJ_NEW_SMALL_INT(hash);
     138                 :            :         }
     139                 :       4387 :         case MP_UNARY_OP_LEN:
     140                 :       4387 :             return MP_OBJ_NEW_SMALL_INT(self->len);
     141                 :            :         default:
     142                 :            :             return MP_OBJ_NULL;      // op not supported
     143                 :            :     }
     144                 :            : }
     145                 :            : 
     146                 :       1081 : mp_obj_t mp_obj_tuple_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
     147                 :       1081 :     mp_obj_tuple_t *o = MP_OBJ_TO_PTR(lhs);
     148   [ +  +  +  + ]:       1081 :     switch (op) {
     149                 :        164 :         case MP_BINARY_OP_ADD:
     150                 :            :         case MP_BINARY_OP_INPLACE_ADD: {
     151         [ +  + ]:        164 :             if (!mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(mp_obj_get_type(rhs)), MP_OBJ_FROM_PTR(&mp_type_tuple))) {
     152                 :            :                 return MP_OBJ_NULL; // op not supported
     153                 :            :             }
     154                 :        160 :             mp_obj_tuple_t *p = MP_OBJ_TO_PTR(rhs);
     155                 :        160 :             mp_obj_tuple_t *s = MP_OBJ_TO_PTR(mp_obj_new_tuple(o->len + p->len, NULL));
     156                 :        160 :             mp_seq_cat(s->items, o->items, o->len, p->items, p->len, mp_obj_t);
     157                 :        160 :             return MP_OBJ_FROM_PTR(s);
     158                 :            :         }
     159                 :         64 :         case MP_BINARY_OP_MULTIPLY:
     160                 :            :         case MP_BINARY_OP_INPLACE_MULTIPLY: {
     161                 :         64 :             mp_int_t n;
     162         [ +  + ]:         64 :             if (!mp_obj_get_int_maybe(rhs, &n)) {
     163                 :            :                 return MP_OBJ_NULL; // op not supported
     164                 :            :             }
     165         [ +  + ]:         60 :             if (n <= 0) {
     166                 :            :                 return mp_const_empty_tuple;
     167                 :            :             }
     168                 :         36 :             mp_obj_tuple_t *s = MP_OBJ_TO_PTR(mp_obj_new_tuple(o->len * n, NULL));
     169                 :         36 :             mp_seq_multiply(o->items, sizeof(*o->items), o->len, n, s->items);
     170                 :         36 :             return MP_OBJ_FROM_PTR(s);
     171                 :            :         }
     172                 :        626 :         case MP_BINARY_OP_EQUAL:
     173                 :            :         case MP_BINARY_OP_LESS:
     174                 :            :         case MP_BINARY_OP_LESS_EQUAL:
     175                 :            :         case MP_BINARY_OP_MORE:
     176                 :            :         case MP_BINARY_OP_MORE_EQUAL:
     177                 :        626 :             return tuple_cmp_helper(op, lhs, rhs);
     178                 :            : 
     179                 :            :         default:
     180                 :            :             return MP_OBJ_NULL; // op not supported
     181                 :            :     }
     182                 :            : }
     183                 :            : 
     184                 :     114025 : mp_obj_t mp_obj_tuple_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
     185         [ +  + ]:     114025 :     if (value == MP_OBJ_SENTINEL) {
     186                 :            :         // load
     187                 :     114017 :         mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
     188                 :            :         #if MICROPY_PY_BUILTINS_SLICE
     189   [ -  +  -  +  :     114017 :         if (mp_obj_is_type(index, &mp_type_slice)) {
          -  +  -  +  +  
                +  +  - ]
     190                 :         47 :             mp_bound_slice_t slice;
     191         [ +  + ]:         47 :             if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice)) {
     192                 :          2 :                 mp_raise_NotImplementedError(MP_ERROR_TEXT("only slices with step=1 (aka None) are supported"));
     193                 :            :             }
     194                 :         45 :             mp_obj_tuple_t *res = MP_OBJ_TO_PTR(mp_obj_new_tuple(slice.stop - slice.start, NULL));
     195                 :         45 :             mp_seq_copy(res->items, self->items + slice.start, res->len, mp_obj_t);
     196                 :         45 :             return MP_OBJ_FROM_PTR(res);
     197                 :            :         }
     198                 :            :         #endif
     199                 :     113970 :         size_t index_value = mp_get_index(self->base.type, self->len, index, false);
     200                 :     113970 :         return self->items[index_value];
     201                 :            :     } else {
     202                 :            :         return MP_OBJ_NULL; // op not supported
     203                 :            :     }
     204                 :            : }
     205                 :            : 
     206                 :          8 : STATIC mp_obj_t tuple_count(mp_obj_t self_in, mp_obj_t value) {
     207                 :          8 :     mp_check_self(mp_obj_is_type(self_in, &mp_type_tuple));
     208                 :          8 :     mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
     209                 :          8 :     return mp_seq_count_obj(self->items, self->len, value);
     210                 :            : }
     211                 :            : STATIC MP_DEFINE_CONST_FUN_OBJ_2(tuple_count_obj, tuple_count);
     212                 :            : 
     213                 :         36 : STATIC mp_obj_t tuple_index(size_t n_args, const mp_obj_t *args) {
     214                 :         36 :     mp_check_self(mp_obj_is_type(args[0], &mp_type_tuple));
     215                 :         36 :     mp_obj_tuple_t *self = MP_OBJ_TO_PTR(args[0]);
     216                 :         36 :     return mp_seq_index_obj(self->items, self->len, n_args, args);
     217                 :            : }
     218                 :            : STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(tuple_index_obj, 2, 4, tuple_index);
     219                 :            : 
     220                 :            : STATIC const mp_rom_map_elem_t tuple_locals_dict_table[] = {
     221                 :            :     { MP_ROM_QSTR(MP_QSTR_count), MP_ROM_PTR(&tuple_count_obj) },
     222                 :            :     { MP_ROM_QSTR(MP_QSTR_index), MP_ROM_PTR(&tuple_index_obj) },
     223                 :            : };
     224                 :            : 
     225                 :            : STATIC MP_DEFINE_CONST_DICT(tuple_locals_dict, tuple_locals_dict_table);
     226                 :            : 
     227                 :            : MP_DEFINE_CONST_OBJ_TYPE(
     228                 :            :     mp_type_tuple,
     229                 :            :     MP_QSTR_tuple,
     230                 :            :     MP_TYPE_FLAG_ITER_IS_GETITER,
     231                 :            :     make_new, mp_obj_tuple_make_new,
     232                 :            :     print, mp_obj_tuple_print,
     233                 :            :     unary_op, mp_obj_tuple_unary_op,
     234                 :            :     binary_op, mp_obj_tuple_binary_op,
     235                 :            :     subscr, mp_obj_tuple_subscr,
     236                 :            :     iter, mp_obj_tuple_getiter,
     237                 :            :     locals_dict, &tuple_locals_dict
     238                 :            :     );
     239                 :            : 
     240                 :            : // the zero-length tuple
     241                 :            : const mp_obj_tuple_t mp_const_empty_tuple_obj = {{&mp_type_tuple}, 0};
     242                 :            : 
     243                 :     163027 : mp_obj_t mp_obj_new_tuple(size_t n, const mp_obj_t *items) {
     244         [ +  + ]:     163027 :     if (n == 0) {
     245                 :            :         return mp_const_empty_tuple;
     246                 :            :     }
     247                 :     159541 :     mp_obj_tuple_t *o = mp_obj_malloc_var(mp_obj_tuple_t, mp_obj_t, n, &mp_type_tuple);
     248                 :     159537 :     o->len = n;
     249         [ +  + ]:     159537 :     if (items) {
     250         [ +  + ]:     686400 :         for (size_t i = 0; i < n; i++) {
     251                 :     580571 :             o->items[i] = items[i];
     252                 :            :         }
     253                 :            :     }
     254                 :            :     return MP_OBJ_FROM_PTR(o);
     255                 :            : }
     256                 :            : 
     257                 :     150838 : void mp_obj_tuple_get(mp_obj_t self_in, size_t *len, mp_obj_t **items) {
     258   [ +  -  -  + ]:     150838 :     assert(mp_obj_is_tuple_compatible(self_in));
     259                 :     150838 :     mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
     260                 :     150838 :     *len = self->len;
     261                 :     150838 :     *items = &self->items[0];
     262                 :     150838 : }
     263                 :            : 
     264                 :          8 : void mp_obj_tuple_del(mp_obj_t self_in) {
     265   [ +  -  -  + ]:          8 :     assert(mp_obj_is_type(self_in, &mp_type_tuple));
     266                 :          8 :     mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
     267                 :          8 :     m_del_var(mp_obj_tuple_t, mp_obj_t, self->len, self);
     268                 :          8 : }
     269                 :            : 
     270                 :            : /******************************************************************************/
     271                 :            : /* tuple iterator                                                             */
     272                 :            : 
     273                 :            : typedef struct _mp_obj_tuple_it_t {
     274                 :            :     mp_obj_base_t base;
     275                 :            :     mp_fun_1_t iternext;
     276                 :            :     mp_obj_tuple_t *tuple;
     277                 :            :     size_t cur;
     278                 :            : } mp_obj_tuple_it_t;
     279                 :            : 
     280                 :      15421 : STATIC mp_obj_t tuple_it_iternext(mp_obj_t self_in) {
     281                 :      15421 :     mp_obj_tuple_it_t *self = MP_OBJ_TO_PTR(self_in);
     282         [ +  + ]:      15421 :     if (self->cur < self->tuple->len) {
     283                 :      12522 :         mp_obj_t o_out = self->tuple->items[self->cur];
     284                 :      12522 :         self->cur += 1;
     285                 :      12522 :         return o_out;
     286                 :            :     } else {
     287                 :            :         return MP_OBJ_STOP_ITERATION;
     288                 :            :     }
     289                 :            : }
     290                 :            : 
     291                 :       5149 : mp_obj_t mp_obj_tuple_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) {
     292                 :       5149 :     assert(sizeof(mp_obj_tuple_it_t) <= sizeof(mp_obj_iter_buf_t));
     293                 :       5149 :     mp_obj_tuple_it_t *o = (mp_obj_tuple_it_t *)iter_buf;
     294                 :       5149 :     o->base.type = &mp_type_polymorph_iter;
     295                 :       5149 :     o->iternext = tuple_it_iternext;
     296                 :       5149 :     o->tuple = MP_OBJ_TO_PTR(o_in);
     297                 :       5149 :     o->cur = 0;
     298                 :       5149 :     return MP_OBJ_FROM_PTR(o);
     299                 :            : }

Generated by: LCOV version 1.15-5-g462f71d