LCOV - code coverage report
Current view: top level - py - modbuiltins.c (source / functions) Hit Total Coverage
Test: unix_coverage_v1.23.0-134-g7fe8f030e.info Lines: 221 232 95.3 %
Date: 2024-07-24 10:19:04 Functions: 32 33 97.0 %
Branches: 111 122 91.0 %

           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                 :            :  *
       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 <stdio.h>
      28                 :            : #include <assert.h>
      29                 :            : 
      30                 :            : #include "py/smallint.h"
      31                 :            : #include "py/objint.h"
      32                 :            : #include "py/objstr.h"
      33                 :            : #include "py/objtype.h"
      34                 :            : #include "py/runtime.h"
      35                 :            : #include "py/builtin.h"
      36                 :            : #include "py/stream.h"
      37                 :            : 
      38                 :            : #if MICROPY_PY_BUILTINS_FLOAT
      39                 :            : #include <math.h>
      40                 :            : #endif
      41                 :            : 
      42                 :            : #if MICROPY_PY_IO
      43                 :            : extern struct _mp_dummy_t mp_sys_stdout_obj; // type is irrelevant, just need pointer
      44                 :            : #endif
      45                 :            : 
      46                 :            : // args[0] is function from class body
      47                 :            : // args[1] is class name
      48                 :            : // args[2:] are base objects
      49                 :       1576 : static mp_obj_t mp_builtin___build_class__(size_t n_args, const mp_obj_t *args) {
      50         [ -  + ]:       1576 :     assert(2 <= n_args);
      51                 :            : 
      52                 :            :     // set the new classes __locals__ object
      53                 :       1576 :     mp_obj_dict_t *old_locals = mp_locals_get();
      54                 :       1576 :     mp_obj_t class_locals = mp_obj_new_dict(0);
      55                 :       1576 :     mp_locals_set(MP_OBJ_TO_PTR(class_locals));
      56                 :            : 
      57                 :            :     // call the class code
      58                 :       1576 :     mp_obj_t cell = mp_call_function_0(args[0]);
      59                 :            : 
      60                 :            :     // restore old __locals__ object
      61                 :       1576 :     mp_locals_set(old_locals);
      62                 :            : 
      63                 :            :     // get the class type (meta object) from the base objects
      64                 :       1576 :     mp_obj_t meta;
      65         [ +  + ]:       1576 :     if (n_args == 2) {
      66                 :            :         // no explicit bases, so use 'type'
      67                 :            :         meta = MP_OBJ_FROM_PTR(&mp_type_type);
      68                 :            :     } else {
      69                 :            :         // use type of first base object
      70                 :        456 :         meta = MP_OBJ_FROM_PTR(mp_obj_get_type(args[2]));
      71                 :            :     }
      72                 :            : 
      73                 :            :     // TODO do proper metaclass resolution for multiple base objects
      74                 :            : 
      75                 :            :     // create the new class using a call to the meta object
      76                 :       1576 :     mp_obj_t meta_args[3];
      77                 :       1576 :     meta_args[0] = args[1]; // class name
      78                 :       1576 :     meta_args[1] = mp_obj_new_tuple(n_args - 2, args + 2); // tuple of bases
      79                 :       1576 :     meta_args[2] = class_locals; // dict of members
      80                 :       1576 :     mp_obj_t new_class = mp_call_function_n_kw(meta, 3, 0, meta_args);
      81                 :            : 
      82                 :            :     // store into cell if needed
      83         [ +  + ]:       1568 :     if (cell != mp_const_none) {
      84                 :         54 :         mp_obj_cell_set(cell, new_class);
      85                 :            :     }
      86                 :            : 
      87                 :       1568 :     return new_class;
      88                 :            : }
      89                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR(mp_builtin___build_class___obj, 2, mp_builtin___build_class__);
      90                 :            : 
      91                 :      28464 : static mp_obj_t mp_builtin_abs(mp_obj_t o_in) {
      92                 :      28464 :     return mp_unary_op(MP_UNARY_OP_ABS, o_in);
      93                 :            : }
      94                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_abs_obj, mp_builtin_abs);
      95                 :            : 
      96                 :         44 : static mp_obj_t mp_builtin_all(mp_obj_t o_in) {
      97                 :         44 :     mp_obj_iter_buf_t iter_buf;
      98                 :         44 :     mp_obj_t iterable = mp_getiter(o_in, &iter_buf);
      99                 :         44 :     mp_obj_t item;
     100         [ +  + ]:         72 :     while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
     101         [ +  + ]:         48 :         if (!mp_obj_is_true(item)) {
     102                 :            :             return mp_const_false;
     103                 :            :         }
     104                 :            :     }
     105                 :            :     return mp_const_true;
     106                 :            : }
     107                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_all_obj, mp_builtin_all);
     108                 :            : 
     109                 :        112 : static mp_obj_t mp_builtin_any(mp_obj_t o_in) {
     110                 :        112 :     mp_obj_iter_buf_t iter_buf;
     111                 :        112 :     mp_obj_t iterable = mp_getiter(o_in, &iter_buf);
     112                 :        112 :     mp_obj_t item;
     113         [ +  + ]:        200 :     while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
     114         [ +  + ]:        184 :         if (mp_obj_is_true(item)) {
     115                 :            :             return mp_const_true;
     116                 :            :         }
     117                 :            :     }
     118                 :            :     return mp_const_false;
     119                 :            : }
     120                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_any_obj, mp_builtin_any);
     121                 :            : 
     122                 :       5144 : static mp_obj_t mp_builtin_bin(mp_obj_t o_in) {
     123                 :       5144 :     mp_obj_t args[] = { MP_OBJ_NEW_QSTR(MP_QSTR__brace_open__colon__hash_b_brace_close_), o_in };
     124                 :       5144 :     return mp_obj_str_format(MP_ARRAY_SIZE(args), args, NULL);
     125                 :            : }
     126                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_bin_obj, mp_builtin_bin);
     127                 :            : 
     128                 :        194 : static mp_obj_t mp_builtin_callable(mp_obj_t o_in) {
     129         [ +  + ]:        194 :     if (mp_obj_is_callable(o_in)) {
     130                 :            :         return mp_const_true;
     131                 :            :     } else {
     132                 :        136 :         return mp_const_false;
     133                 :            :     }
     134                 :            : }
     135                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_callable_obj, mp_builtin_callable);
     136                 :            : 
     137                 :      20080 : static mp_obj_t mp_builtin_chr(mp_obj_t o_in) {
     138                 :            :     #if MICROPY_PY_BUILTINS_STR_UNICODE
     139                 :      20080 :     mp_uint_t c = mp_obj_get_int(o_in);
     140         [ +  + ]:      20080 :     if (c >= 0x110000) {
     141                 :          4 :         mp_raise_ValueError(MP_ERROR_TEXT("chr() arg not in range(0x110000)"));
     142                 :            :     }
     143                 :      20076 :     VSTR_FIXED(buf, 4);
     144                 :      20076 :     vstr_add_char(&buf, c);
     145                 :      20076 :     return mp_obj_new_str_via_qstr(buf.buf, buf.len);
     146                 :            :     #else
     147                 :            :     mp_int_t ord = mp_obj_get_int(o_in);
     148                 :            :     if (0 <= ord && ord <= 0xff) {
     149                 :            :         uint8_t str[1] = {ord};
     150                 :            :         return mp_obj_new_str_via_qstr((char *)str, 1);
     151                 :            :     } else {
     152                 :            :         mp_raise_ValueError(MP_ERROR_TEXT("chr() arg not in range(256)"));
     153                 :            :     }
     154                 :            :     #endif
     155                 :            : }
     156                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_chr_obj, mp_builtin_chr);
     157                 :            : 
     158                 :         38 : static mp_obj_t mp_builtin_dir(size_t n_args, const mp_obj_t *args) {
     159                 :         38 :     mp_obj_t dir = mp_obj_new_list(0, NULL);
     160         [ +  + ]:         38 :     if (n_args == 0) {
     161                 :            :         // Make a list of names in the local namespace
     162                 :          4 :         mp_obj_dict_t *dict = mp_locals_get();
     163         [ +  + ]:         20 :         for (size_t i = 0; i < dict->map.alloc; i++) {
     164         [ +  + ]:         16 :             if (mp_map_slot_is_filled(&dict->map, i)) {
     165                 :         14 :                 mp_obj_list_append(dir, dict->map.table[i].key);
     166                 :            :             }
     167                 :            :         }
     168                 :            :     } else { // n_args == 1
     169                 :            :         // Make a list of names in the given object
     170                 :            :         // Implemented by probing all possible qstrs with mp_load_method_maybe
     171                 :         34 :         size_t nqstr = QSTR_TOTAL();
     172         [ +  + ]:      25120 :         for (size_t i = MP_QSTR_ + 1; i < nqstr; ++i) {
     173                 :      25090 :             mp_obj_t dest[2];
     174                 :      25090 :             mp_load_method_protected(args[0], i, dest, false);
     175         [ +  + ]:      25090 :             if (dest[0] != MP_OBJ_NULL) {
     176                 :            :                 #if MICROPY_PY_ALL_SPECIAL_METHODS
     177                 :            :                 // Support for __dir__: see if we can dispatch to this special method
     178                 :            :                 // This relies on MP_QSTR__dir__ being first after MP_QSTR_
     179   [ +  +  +  + ]:        418 :                 if (i == MP_QSTR___dir__ && dest[1] != MP_OBJ_NULL) {
     180                 :          4 :                     return mp_call_method_n_kw(0, 0, dest);
     181                 :            :                 }
     182                 :            :                 #endif
     183                 :        414 :                 mp_obj_list_append(dir, MP_OBJ_NEW_QSTR(i));
     184                 :            :             }
     185                 :            :         }
     186                 :            :     }
     187                 :            :     return dir;
     188                 :            : }
     189                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_dir_obj, 0, 1, mp_builtin_dir);
     190                 :            : 
     191                 :       5272 : static mp_obj_t mp_builtin_divmod(mp_obj_t o1_in, mp_obj_t o2_in) {
     192                 :       5272 :     return mp_binary_op(MP_BINARY_OP_DIVMOD, o1_in, o2_in);
     193                 :            : }
     194                 :            : MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_divmod_obj, mp_builtin_divmod);
     195                 :            : 
     196                 :        258 : static mp_obj_t mp_builtin_hash(mp_obj_t o_in) {
     197                 :            :     // result is guaranteed to be a (small) int
     198                 :        258 :     return mp_unary_op(MP_UNARY_OP_HASH, o_in);
     199                 :            : }
     200                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_hash_obj, mp_builtin_hash);
     201                 :            : 
     202                 :        188 : static mp_obj_t mp_builtin_hex(mp_obj_t o_in) {
     203                 :            :     #if MICROPY_PY_BUILTINS_STR_OP_MODULO
     204                 :        188 :     return mp_binary_op(MP_BINARY_OP_MODULO, MP_OBJ_NEW_QSTR(MP_QSTR__percent__hash_x), o_in);
     205                 :            :     #else
     206                 :            :     mp_obj_t args[] = { MP_OBJ_NEW_QSTR(MP_QSTR__brace_open__colon__hash_x_brace_close_), o_in };
     207                 :            :     return mp_obj_str_format(MP_ARRAY_SIZE(args), args, NULL);
     208                 :            :     #endif
     209                 :            : }
     210                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_hex_obj, mp_builtin_hex);
     211                 :            : 
     212                 :            : #if MICROPY_PY_BUILTINS_INPUT
     213                 :            : 
     214                 :            : #include "py/mphal.h"
     215                 :            : #include "shared/readline/readline.h"
     216                 :            : 
     217                 :            : // A port can define mp_hal_readline if they want to use a custom function here
     218                 :            : #ifndef mp_hal_readline
     219                 :            : #define mp_hal_readline readline
     220                 :            : #endif
     221                 :            : 
     222                 :          0 : static mp_obj_t mp_builtin_input(size_t n_args, const mp_obj_t *args) {
     223         [ #  # ]:          0 :     if (n_args == 1) {
     224                 :          0 :         mp_obj_print(args[0], PRINT_STR);
     225                 :            :     }
     226                 :          0 :     vstr_t line;
     227                 :          0 :     vstr_init(&line, 16);
     228                 :          0 :     int ret = mp_hal_readline(&line, "");
     229         [ #  # ]:          0 :     if (ret == CHAR_CTRL_C) {
     230                 :          0 :         mp_raise_type(&mp_type_KeyboardInterrupt);
     231                 :            :     }
     232   [ #  #  #  # ]:          0 :     if (line.len == 0 && ret == CHAR_CTRL_D) {
     233                 :          0 :         mp_raise_type(&mp_type_EOFError);
     234                 :            :     }
     235                 :          0 :     return mp_obj_new_str_from_vstr(&line);
     236                 :            : }
     237                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_input_obj, 0, 1, mp_builtin_input);
     238                 :            : 
     239                 :            : #endif
     240                 :            : 
     241                 :        126 : static mp_obj_t mp_builtin_iter(mp_obj_t o_in) {
     242                 :        126 :     return mp_getiter(o_in, NULL);
     243                 :            : }
     244                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_iter_obj, mp_builtin_iter);
     245                 :            : 
     246                 :            : #if MICROPY_PY_BUILTINS_MIN_MAX
     247                 :            : 
     248                 :     295234 : static mp_obj_t mp_builtin_min_max(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs, mp_uint_t op) {
     249                 :     295234 :     mp_map_elem_t *key_elem = mp_map_lookup(kwargs, MP_OBJ_NEW_QSTR(MP_QSTR_key), MP_MAP_LOOKUP);
     250                 :     295234 :     mp_map_elem_t *default_elem;
     251         [ +  + ]:     295234 :     mp_obj_t key_fn = key_elem == NULL ? MP_OBJ_NULL : key_elem->value;
     252         [ +  + ]:     295234 :     if (n_args == 1) {
     253                 :            :         // given an iterable
     254                 :         80 :         mp_obj_iter_buf_t iter_buf;
     255                 :         80 :         mp_obj_t iterable = mp_getiter(args[0], &iter_buf);
     256                 :         80 :         mp_obj_t best_key = MP_OBJ_NULL;
     257                 :         80 :         mp_obj_t best_obj = MP_OBJ_NULL;
     258                 :         80 :         mp_obj_t item;
     259         [ +  + ]:        400 :         while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
     260         [ +  + ]:        320 :             mp_obj_t key = key_fn == MP_OBJ_NULL ? item : mp_call_function_1(key_fn, item);
     261   [ +  +  +  + ]:        320 :             if (best_obj == MP_OBJ_NULL || (mp_binary_op(op, key, best_key) == mp_const_true)) {
     262                 :            :                 best_key = key;
     263                 :            :                 best_obj = item;
     264                 :            :             }
     265                 :            :         }
     266         [ +  + ]:         80 :         if (best_obj == MP_OBJ_NULL) {
     267                 :         16 :             default_elem = mp_map_lookup(kwargs, MP_OBJ_NEW_QSTR(MP_QSTR_default), MP_MAP_LOOKUP);
     268         [ +  + ]:         16 :             if (default_elem != NULL) {
     269                 :         12 :                 best_obj = default_elem->value;
     270                 :            :             } else {
     271                 :          4 :                 mp_raise_ValueError(MP_ERROR_TEXT("arg is an empty sequence"));
     272                 :            :             }
     273                 :            :         }
     274                 :         76 :         return best_obj;
     275                 :            :     } else {
     276                 :            :         // given many args
     277                 :            :         mp_obj_t best_key = MP_OBJ_NULL;
     278                 :            :         mp_obj_t best_obj = MP_OBJ_NULL;
     279         [ +  + ]:     885494 :         for (size_t i = 0; i < n_args; i++) {
     280         [ +  + ]:     590340 :             mp_obj_t key = key_fn == MP_OBJ_NULL ? args[i] : mp_call_function_1(key_fn, args[i]);
     281   [ +  +  +  + ]:     590340 :             if (best_obj == MP_OBJ_NULL || (mp_binary_op(op, key, best_key) == mp_const_true)) {
     282                 :     295639 :                 best_key = key;
     283                 :     295639 :                 best_obj = args[i];
     284                 :            :             }
     285                 :            :         }
     286                 :            :         return best_obj;
     287                 :            :     }
     288                 :            : }
     289                 :            : 
     290                 :     295048 : static mp_obj_t mp_builtin_max(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
     291                 :     295048 :     return mp_builtin_min_max(n_args, args, kwargs, MP_BINARY_OP_MORE);
     292                 :            : }
     293                 :            : MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_max_obj, 1, mp_builtin_max);
     294                 :            : 
     295                 :        186 : static mp_obj_t mp_builtin_min(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
     296                 :        186 :     return mp_builtin_min_max(n_args, args, kwargs, MP_BINARY_OP_LESS);
     297                 :            : }
     298                 :            : MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_min_obj, 1, mp_builtin_min);
     299                 :            : 
     300                 :            : #endif
     301                 :            : 
     302                 :            : #if MICROPY_PY_BUILTINS_NEXT2
     303                 :        753 : static mp_obj_t mp_builtin_next(size_t n_args, const mp_obj_t *args) {
     304         [ +  + ]:        753 :     if (n_args == 1) {
     305                 :        717 :         mp_obj_t ret = mp_iternext_allow_raise(args[0]);
     306         [ +  + ]:        659 :         if (ret == MP_OBJ_STOP_ITERATION) {
     307                 :        182 :             mp_raise_StopIteration(MP_STATE_THREAD(stop_iteration_arg));
     308                 :            :         } else {
     309                 :            :             return ret;
     310                 :            :         }
     311                 :            :     } else {
     312                 :         36 :         mp_obj_t ret = mp_iternext(args[0]);
     313         [ +  + ]:         36 :         return ret == MP_OBJ_STOP_ITERATION ? args[1] : ret;
     314                 :            :     }
     315                 :            : }
     316                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_next_obj, 1, 2, mp_builtin_next);
     317                 :            : #else
     318                 :            : static mp_obj_t mp_builtin_next(mp_obj_t o) {
     319                 :            :     mp_obj_t ret = mp_iternext_allow_raise(o);
     320                 :            :     if (ret == MP_OBJ_STOP_ITERATION) {
     321                 :            :         mp_raise_StopIteration(MP_STATE_THREAD(stop_iteration_arg));
     322                 :            :     } else {
     323                 :            :         return ret;
     324                 :            :     }
     325                 :            : }
     326                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_next_obj, mp_builtin_next);
     327                 :            : #endif
     328                 :            : 
     329                 :         32 : static mp_obj_t mp_builtin_oct(mp_obj_t o_in) {
     330                 :            :     #if MICROPY_PY_BUILTINS_STR_OP_MODULO
     331                 :         32 :     return mp_binary_op(MP_BINARY_OP_MODULO, MP_OBJ_NEW_QSTR(MP_QSTR__percent__hash_o), o_in);
     332                 :            :     #else
     333                 :            :     mp_obj_t args[] = { MP_OBJ_NEW_QSTR(MP_QSTR__brace_open__colon__hash_o_brace_close_), o_in };
     334                 :            :     return mp_obj_str_format(MP_ARRAY_SIZE(args), args, NULL);
     335                 :            :     #endif
     336                 :            : }
     337                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_oct_obj, mp_builtin_oct);
     338                 :            : 
     339                 :      19672 : static mp_obj_t mp_builtin_ord(mp_obj_t o_in) {
     340                 :      19672 :     size_t len;
     341                 :      19672 :     const byte *str = (const byte *)mp_obj_str_get_data(o_in, &len);
     342                 :            :     #if MICROPY_PY_BUILTINS_STR_UNICODE
     343   [ +  +  +  -  :      19668 :     if (mp_obj_is_str(o_in)) {
                   -  + ]
     344                 :      19636 :         len = utf8_charlen(str, len);
     345         [ +  + ]:      19636 :         if (len == 1) {
     346                 :      19632 :             return mp_obj_new_int(utf8_get_char(str));
     347                 :            :         }
     348                 :            :     } else
     349                 :            :     #endif
     350                 :            :     {
     351                 :            :         // a bytes object, or a str without unicode support (don't sign extend the char)
     352         [ +  + ]:         32 :         if (len == 1) {
     353                 :         28 :             return MP_OBJ_NEW_SMALL_INT(str[0]);
     354                 :            :         }
     355                 :            :     }
     356                 :            : 
     357                 :            :     #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
     358                 :            :     mp_raise_TypeError(MP_ERROR_TEXT("ord expects a character"));
     359                 :            :     #else
     360                 :          8 :     mp_raise_msg_varg(&mp_type_TypeError,
     361                 :          8 :         MP_ERROR_TEXT("ord() expected a character, but string of length %d found"), (int)len);
     362                 :            :     #endif
     363                 :            : }
     364                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_ord_obj, mp_builtin_ord);
     365                 :            : 
     366                 :       1248 : static mp_obj_t mp_builtin_pow(size_t n_args, const mp_obj_t *args) {
     367         [ +  + ]:       1248 :     switch (n_args) {
     368                 :       1188 :         case 2:
     369                 :       1188 :             return mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]);
     370                 :         60 :         default:
     371                 :            :             #if !MICROPY_PY_BUILTINS_POW3
     372                 :            :             mp_raise_NotImplementedError(MP_ERROR_TEXT("3-arg pow() not supported"));
     373                 :            :             #elif MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_MPZ
     374                 :            :             return mp_binary_op(MP_BINARY_OP_MODULO, mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]), args[2]);
     375                 :            :             #else
     376                 :         60 :             return mp_obj_int_pow3(args[0], args[1], args[2]);
     377                 :            :             #endif
     378                 :            :     }
     379                 :            : }
     380                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_pow_obj, 2, 3, mp_builtin_pow);
     381                 :            : 
     382                 :     183545 : static mp_obj_t mp_builtin_print(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     383                 :     183545 :     enum { ARG_sep, ARG_end, ARG_file };
     384                 :     183545 :     static const mp_arg_t allowed_args[] = {
     385                 :            :         { MP_QSTR_sep, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR__space_)} },
     386                 :            :         { MP_QSTR_end, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR__0x0a_)} },
     387                 :            :         #if MICROPY_PY_IO && MICROPY_PY_SYS_STDFILES
     388                 :            :         { MP_QSTR_file, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_sys_stdout_obj)} },
     389                 :            :         #endif
     390                 :            :     };
     391                 :            : 
     392                 :            :     // parse args (a union is used to reduce the amount of C stack that is needed)
     393                 :     183545 :     union {
     394                 :            :         mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     395                 :            :         size_t len[2];
     396                 :            :     } u;
     397                 :     183545 :     mp_arg_parse_all(0, NULL, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, u.args);
     398                 :            : 
     399                 :            :     #if MICROPY_PY_IO && MICROPY_PY_SYS_STDFILES
     400                 :     183529 :     mp_get_stream_raise(u.args[ARG_file].u_obj, MP_STREAM_OP_WRITE);
     401                 :     183527 :     mp_print_t print = {MP_OBJ_TO_PTR(u.args[ARG_file].u_obj), mp_stream_write_adaptor};
     402                 :            :     #endif
     403                 :            : 
     404                 :            :     // extract the objects first because we are going to use the other part of the union
     405                 :     183527 :     mp_obj_t sep = u.args[ARG_sep].u_obj;
     406                 :     183527 :     mp_obj_t end = u.args[ARG_end].u_obj;
     407                 :     183527 :     const char *sep_data = mp_obj_str_get_data(sep, &u.len[0]);
     408                 :     183527 :     const char *end_data = mp_obj_str_get_data(end, &u.len[1]);
     409                 :            : 
     410         [ +  + ]:     459612 :     for (size_t i = 0; i < n_args; i++) {
     411         [ +  + ]:     276087 :         if (i > 0) {
     412                 :            :             #if MICROPY_PY_IO && MICROPY_PY_SYS_STDFILES
     413                 :      95300 :             mp_stream_write_adaptor(print.data, sep_data, u.len[0]);
     414                 :            :             #else
     415                 :            :             mp_print_strn(&mp_plat_print, sep_data, u.len[0], 0, 0, 0);
     416                 :            :             #endif
     417                 :            :         }
     418                 :            :         #if MICROPY_PY_IO && MICROPY_PY_SYS_STDFILES
     419                 :     276087 :         mp_obj_print_helper(&print, pos_args[i], PRINT_STR);
     420                 :            :         #else
     421                 :            :         mp_obj_print_helper(&mp_plat_print, pos_args[i], PRINT_STR);
     422                 :            :         #endif
     423                 :            :     }
     424                 :            :     #if MICROPY_PY_IO && MICROPY_PY_SYS_STDFILES
     425                 :     183525 :     mp_stream_write_adaptor(print.data, end_data, u.len[1]);
     426                 :            :     #else
     427                 :            :     mp_print_strn(&mp_plat_print, end_data, u.len[1], 0, 0, 0);
     428                 :            :     #endif
     429                 :     183525 :     return mp_const_none;
     430                 :            : }
     431                 :            : MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_print_obj, 0, mp_builtin_print);
     432                 :            : 
     433                 :        114 : static mp_obj_t mp_builtin___repl_print__(mp_obj_t o) {
     434         [ +  + ]:        114 :     if (o != mp_const_none) {
     435                 :         82 :         mp_obj_print_helper(MP_PYTHON_PRINTER, o, PRINT_REPR);
     436                 :         82 :         mp_print_str(MP_PYTHON_PRINTER, "\n");
     437                 :            :         #if MICROPY_CAN_OVERRIDE_BUILTINS
     438                 :            :         // Set "_" special variable
     439                 :         82 :         mp_obj_t dest[2] = {MP_OBJ_SENTINEL, o};
     440                 :         82 :         MP_OBJ_TYPE_GET_SLOT(&mp_type_module, attr)(MP_OBJ_FROM_PTR(&mp_module_builtins), MP_QSTR__, dest);
     441                 :            :         #endif
     442                 :            :     }
     443                 :        114 :     return mp_const_none;
     444                 :            : }
     445                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin___repl_print___obj, mp_builtin___repl_print__);
     446                 :            : 
     447                 :       1112 : static mp_obj_t mp_builtin_repr(mp_obj_t o_in) {
     448                 :       1112 :     vstr_t vstr;
     449                 :       1112 :     mp_print_t print;
     450                 :       1112 :     vstr_init_print(&vstr, 16, &print);
     451                 :       1112 :     mp_obj_print_helper(&print, o_in, PRINT_REPR);
     452                 :       1112 :     return mp_obj_new_str_from_utf8_vstr(&vstr);
     453                 :            : }
     454                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_repr_obj, mp_builtin_repr);
     455                 :            : 
     456                 :        254 : static mp_obj_t mp_builtin_round(size_t n_args, const mp_obj_t *args) {
     457                 :        254 :     mp_obj_t o_in = args[0];
     458   [ +  +  +  +  :        254 :     if (mp_obj_is_int(o_in)) {
                   +  + ]
     459         [ +  + ]:        122 :         if (n_args <= 1) {
     460                 :            :             return o_in;
     461                 :            :         }
     462                 :            : 
     463                 :            :         #if !MICROPY_PY_BUILTINS_ROUND_INT
     464                 :            :         mp_raise_NotImplementedError(NULL);
     465                 :            :         #else
     466                 :        106 :         mp_int_t num_dig = mp_obj_get_int(args[1]);
     467         [ +  + ]:        106 :         if (num_dig >= 0) {
     468                 :            :             return o_in;
     469                 :            :         }
     470                 :            : 
     471                 :         66 :         mp_obj_t mult = mp_binary_op(MP_BINARY_OP_POWER, MP_OBJ_NEW_SMALL_INT(10), MP_OBJ_NEW_SMALL_INT(-num_dig));
     472                 :         66 :         mp_obj_t half_mult = mp_binary_op(MP_BINARY_OP_FLOOR_DIVIDE, mult, MP_OBJ_NEW_SMALL_INT(2));
     473                 :         66 :         mp_obj_t modulo = mp_binary_op(MP_BINARY_OP_MODULO, o_in, mult);
     474                 :         66 :         mp_obj_t rounded = mp_binary_op(MP_BINARY_OP_SUBTRACT, o_in, modulo);
     475         [ +  + ]:         66 :         if (mp_obj_is_true(mp_binary_op(MP_BINARY_OP_MORE, half_mult, modulo))) {
     476                 :            :             return rounded;
     477         [ +  + ]:         36 :         } else if (mp_obj_is_true(mp_binary_op(MP_BINARY_OP_MORE, modulo, half_mult))) {
     478                 :         16 :             return mp_binary_op(MP_BINARY_OP_ADD, rounded, mult);
     479                 :            :         } else {
     480                 :            :             // round to even number
     481                 :         20 :             mp_obj_t floor = mp_binary_op(MP_BINARY_OP_FLOOR_DIVIDE, o_in, mult);
     482         [ +  + ]:         20 :             if (mp_obj_is_true(mp_binary_op(MP_BINARY_OP_AND, floor, MP_OBJ_NEW_SMALL_INT(1)))) {
     483                 :          4 :                 return mp_binary_op(MP_BINARY_OP_ADD, rounded, mult);
     484                 :            :             } else {
     485                 :            :                 return rounded;
     486                 :            :             }
     487                 :            :         }
     488                 :            :         #endif
     489                 :            :     }
     490                 :            :     #if MICROPY_PY_BUILTINS_FLOAT
     491                 :        132 :     mp_float_t val = mp_obj_get_float(o_in);
     492         [ +  + ]:        132 :     if (n_args > 1) {
     493                 :         32 :         mp_int_t num_dig = mp_obj_get_int(args[1]);
     494                 :         32 :         mp_float_t mult = MICROPY_FLOAT_C_FUN(pow)(10, (mp_float_t)num_dig);
     495                 :            :         // TODO may lead to overflow
     496                 :         32 :         mp_float_t rounded = MICROPY_FLOAT_C_FUN(nearbyint)(val * mult) / mult;
     497                 :         32 :         return mp_obj_new_float(rounded);
     498                 :            :     }
     499                 :        100 :     mp_float_t rounded = MICROPY_FLOAT_C_FUN(nearbyint)(val);
     500                 :        100 :     return mp_obj_new_int_from_float(rounded);
     501                 :            :     #else
     502                 :            :     mp_int_t r = mp_obj_get_int(o_in);
     503                 :            :     return mp_obj_new_int(r);
     504                 :            :     #endif
     505                 :            : }
     506                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_round_obj, 1, 2, mp_builtin_round);
     507                 :            : 
     508                 :         60 : static mp_obj_t mp_builtin_sum(size_t n_args, const mp_obj_t *args) {
     509                 :         60 :     mp_obj_t value;
     510         [ +  + ]:         60 :     switch (n_args) {
     511                 :            :         case 1:
     512                 :            :             value = MP_OBJ_NEW_SMALL_INT(0);
     513                 :            :             break;
     514                 :         24 :         default:
     515                 :         24 :             value = args[1];
     516                 :         24 :             break;
     517                 :            :     }
     518                 :         60 :     mp_obj_iter_buf_t iter_buf;
     519                 :         60 :     mp_obj_t iterable = mp_getiter(args[0], &iter_buf);
     520                 :         60 :     mp_obj_t item;
     521         [ +  + ]:        512 :     while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
     522                 :        452 :         value = mp_binary_op(MP_BINARY_OP_ADD, value, item);
     523                 :            :     }
     524                 :         60 :     return value;
     525                 :            : }
     526                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_sum_obj, 1, 2, mp_builtin_sum);
     527                 :            : 
     528                 :      18724 : static mp_obj_t mp_builtin_sorted(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
     529         [ +  + ]:      18724 :     if (n_args > 1) {
     530                 :          4 :         mp_raise_TypeError(MP_ERROR_TEXT("must use keyword argument for key function"));
     531                 :            :     }
     532                 :      18720 :     mp_obj_t self = mp_obj_list_make_new(&mp_type_list, 1, 0, args);
     533                 :      18720 :     mp_obj_list_sort(1, &self, kwargs);
     534                 :            : 
     535                 :      18720 :     return self;
     536                 :            : }
     537                 :            : MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_sorted_obj, 1, mp_builtin_sorted);
     538                 :            : 
     539                 :            : // See mp_load_attr() if making any changes
     540                 :        668 : static inline mp_obj_t mp_load_attr_default(mp_obj_t base, qstr attr, mp_obj_t defval) {
     541                 :        668 :     mp_obj_t dest[2];
     542                 :            :     // use load_method, raising or not raising exception
     543         [ +  + ]:        668 :     if (defval == MP_OBJ_NULL) {
     544                 :        196 :         mp_load_method(base, attr, dest);
     545                 :            :     } else {
     546                 :        472 :         mp_load_method_protected(base, attr, dest, false);
     547                 :            :     }
     548         [ +  + ]:        668 :     if (dest[0] == MP_OBJ_NULL) {
     549                 :            :         return defval;
     550         [ +  + ]:        506 :     } else if (dest[1] == MP_OBJ_NULL) {
     551                 :            :         // load_method returned just a normal attribute
     552                 :            :         return dest[0];
     553                 :            :     } else {
     554                 :            :         // load_method returned a method, so build a bound method object
     555                 :         16 :         return mp_obj_new_bound_meth(dest[0], dest[1]);
     556                 :            :     }
     557                 :            : }
     558                 :            : 
     559                 :        668 : static mp_obj_t mp_builtin_getattr(size_t n_args, const mp_obj_t *args) {
     560                 :        668 :     mp_obj_t defval = MP_OBJ_NULL;
     561         [ +  + ]:        668 :     if (n_args > 2) {
     562                 :        472 :         defval = args[2];
     563                 :            :     }
     564                 :        668 :     return mp_load_attr_default(args[0], mp_obj_str_get_qstr(args[1]), defval);
     565                 :            : }
     566                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_getattr_obj, 2, 3, mp_builtin_getattr);
     567                 :            : 
     568                 :         50 : static mp_obj_t mp_builtin_setattr(mp_obj_t base, mp_obj_t attr, mp_obj_t value) {
     569                 :         50 :     mp_store_attr(base, mp_obj_str_get_qstr(attr), value);
     570                 :         32 :     return mp_const_none;
     571                 :            : }
     572                 :            : MP_DEFINE_CONST_FUN_OBJ_3(mp_builtin_setattr_obj, mp_builtin_setattr);
     573                 :            : 
     574                 :            : #if MICROPY_CPYTHON_COMPAT
     575                 :         16 : static mp_obj_t mp_builtin_delattr(mp_obj_t base, mp_obj_t attr) {
     576                 :         16 :     return mp_builtin_setattr(base, attr, MP_OBJ_NULL);
     577                 :            : }
     578                 :            : MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_delattr_obj, mp_builtin_delattr);
     579                 :            : #endif
     580                 :            : 
     581                 :        694 : static mp_obj_t mp_builtin_hasattr(mp_obj_t object_in, mp_obj_t attr_in) {
     582                 :        694 :     qstr attr = mp_obj_str_get_qstr(attr_in);
     583                 :        680 :     mp_obj_t dest[2];
     584                 :        680 :     mp_load_method_protected(object_in, attr, dest, false);
     585         [ +  + ]:        676 :     return mp_obj_new_bool(dest[0] != MP_OBJ_NULL);
     586                 :            : }
     587                 :            : MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_hasattr_obj, mp_builtin_hasattr);
     588                 :            : 
     589                 :        726 : static mp_obj_t mp_builtin_globals(void) {
     590                 :        726 :     return MP_OBJ_FROM_PTR(mp_globals_get());
     591                 :            : }
     592                 :            : MP_DEFINE_CONST_FUN_OBJ_0(mp_builtin_globals_obj, mp_builtin_globals);
     593                 :            : 
     594                 :         20 : static mp_obj_t mp_builtin_locals(void) {
     595                 :         20 :     return MP_OBJ_FROM_PTR(mp_locals_get());
     596                 :            : }
     597                 :            : MP_DEFINE_CONST_FUN_OBJ_0(mp_builtin_locals_obj, mp_builtin_locals);
     598                 :            : 
     599                 :            : // These are defined in terms of MicroPython API functions right away
     600                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_id_obj, mp_obj_id);
     601                 :            : MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_len_obj, mp_obj_len);
     602                 :            : 
     603                 :            : static const mp_rom_map_elem_t mp_module_builtins_globals_table[] = {
     604                 :            :     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_builtins) },
     605                 :            : 
     606                 :            :     // built-in core functions
     607                 :            :     { MP_ROM_QSTR(MP_QSTR___build_class__), MP_ROM_PTR(&mp_builtin___build_class___obj) },
     608                 :            :     { MP_ROM_QSTR(MP_QSTR___import__), MP_ROM_PTR(&mp_builtin___import___obj) },
     609                 :            :     { MP_ROM_QSTR(MP_QSTR___repl_print__), MP_ROM_PTR(&mp_builtin___repl_print___obj) },
     610                 :            : 
     611                 :            :     // built-in types
     612                 :            :     { MP_ROM_QSTR(MP_QSTR_bool), MP_ROM_PTR(&mp_type_bool) },
     613                 :            :     { MP_ROM_QSTR(MP_QSTR_bytes), MP_ROM_PTR(&mp_type_bytes) },
     614                 :            :     #if MICROPY_PY_BUILTINS_BYTEARRAY
     615                 :            :     { MP_ROM_QSTR(MP_QSTR_bytearray), MP_ROM_PTR(&mp_type_bytearray) },
     616                 :            :     #endif
     617                 :            :     #if MICROPY_PY_BUILTINS_COMPLEX
     618                 :            :     { MP_ROM_QSTR(MP_QSTR_complex), MP_ROM_PTR(&mp_type_complex) },
     619                 :            :     #endif
     620                 :            :     { MP_ROM_QSTR(MP_QSTR_dict), MP_ROM_PTR(&mp_type_dict) },
     621                 :            :     #if MICROPY_PY_BUILTINS_ENUMERATE
     622                 :            :     { MP_ROM_QSTR(MP_QSTR_enumerate), MP_ROM_PTR(&mp_type_enumerate) },
     623                 :            :     #endif
     624                 :            :     #if MICROPY_PY_BUILTINS_FILTER
     625                 :            :     { MP_ROM_QSTR(MP_QSTR_filter), MP_ROM_PTR(&mp_type_filter) },
     626                 :            :     #endif
     627                 :            :     #if MICROPY_PY_BUILTINS_FLOAT
     628                 :            :     { MP_ROM_QSTR(MP_QSTR_float), MP_ROM_PTR(&mp_type_float) },
     629                 :            :     #endif
     630                 :            :     #if MICROPY_PY_BUILTINS_SET && MICROPY_PY_BUILTINS_FROZENSET
     631                 :            :     { MP_ROM_QSTR(MP_QSTR_frozenset), MP_ROM_PTR(&mp_type_frozenset) },
     632                 :            :     #endif
     633                 :            :     { MP_ROM_QSTR(MP_QSTR_int), MP_ROM_PTR(&mp_type_int) },
     634                 :            :     { MP_ROM_QSTR(MP_QSTR_list), MP_ROM_PTR(&mp_type_list) },
     635                 :            :     { MP_ROM_QSTR(MP_QSTR_map), MP_ROM_PTR(&mp_type_map) },
     636                 :            :     #if MICROPY_PY_BUILTINS_MEMORYVIEW
     637                 :            :     { MP_ROM_QSTR(MP_QSTR_memoryview), MP_ROM_PTR(&mp_type_memoryview) },
     638                 :            :     #endif
     639                 :            :     { MP_ROM_QSTR(MP_QSTR_object), MP_ROM_PTR(&mp_type_object) },
     640                 :            :     #if MICROPY_PY_BUILTINS_PROPERTY
     641                 :            :     { MP_ROM_QSTR(MP_QSTR_property), MP_ROM_PTR(&mp_type_property) },
     642                 :            :     #endif
     643                 :            :     { MP_ROM_QSTR(MP_QSTR_range), MP_ROM_PTR(&mp_type_range) },
     644                 :            :     #if MICROPY_PY_BUILTINS_REVERSED
     645                 :            :     { MP_ROM_QSTR(MP_QSTR_reversed), MP_ROM_PTR(&mp_type_reversed) },
     646                 :            :     #endif
     647                 :            :     #if MICROPY_PY_BUILTINS_SET
     648                 :            :     { MP_ROM_QSTR(MP_QSTR_set), MP_ROM_PTR(&mp_type_set) },
     649                 :            :     #endif
     650                 :            :     #if MICROPY_PY_BUILTINS_SLICE
     651                 :            :     { MP_ROM_QSTR(MP_QSTR_slice), MP_ROM_PTR(&mp_type_slice) },
     652                 :            :     #endif
     653                 :            :     { MP_ROM_QSTR(MP_QSTR_str), MP_ROM_PTR(&mp_type_str) },
     654                 :            :     { MP_ROM_QSTR(MP_QSTR_super), MP_ROM_PTR(&mp_type_super) },
     655                 :            :     { MP_ROM_QSTR(MP_QSTR_tuple), MP_ROM_PTR(&mp_type_tuple) },
     656                 :            :     { MP_ROM_QSTR(MP_QSTR_type), MP_ROM_PTR(&mp_type_type) },
     657                 :            :     { MP_ROM_QSTR(MP_QSTR_zip), MP_ROM_PTR(&mp_type_zip) },
     658                 :            : 
     659                 :            :     { MP_ROM_QSTR(MP_QSTR_classmethod), MP_ROM_PTR(&mp_type_classmethod) },
     660                 :            :     { MP_ROM_QSTR(MP_QSTR_staticmethod), MP_ROM_PTR(&mp_type_staticmethod) },
     661                 :            : 
     662                 :            :     // built-in objects
     663                 :            :     { MP_ROM_QSTR(MP_QSTR_Ellipsis), MP_ROM_PTR(&mp_const_ellipsis_obj) },
     664                 :            :     #if MICROPY_PY_BUILTINS_NOTIMPLEMENTED
     665                 :            :     { MP_ROM_QSTR(MP_QSTR_NotImplemented), MP_ROM_PTR(&mp_const_notimplemented_obj) },
     666                 :            :     #endif
     667                 :            : 
     668                 :            :     // built-in user functions
     669                 :            :     { MP_ROM_QSTR(MP_QSTR_abs), MP_ROM_PTR(&mp_builtin_abs_obj) },
     670                 :            :     { MP_ROM_QSTR(MP_QSTR_all), MP_ROM_PTR(&mp_builtin_all_obj) },
     671                 :            :     { MP_ROM_QSTR(MP_QSTR_any), MP_ROM_PTR(&mp_builtin_any_obj) },
     672                 :            :     { MP_ROM_QSTR(MP_QSTR_bin), MP_ROM_PTR(&mp_builtin_bin_obj) },
     673                 :            :     { MP_ROM_QSTR(MP_QSTR_callable), MP_ROM_PTR(&mp_builtin_callable_obj) },
     674                 :            :     #if MICROPY_PY_BUILTINS_COMPILE
     675                 :            :     { MP_ROM_QSTR(MP_QSTR_compile), MP_ROM_PTR(&mp_builtin_compile_obj) },
     676                 :            :     #endif
     677                 :            :     { MP_ROM_QSTR(MP_QSTR_chr), MP_ROM_PTR(&mp_builtin_chr_obj) },
     678                 :            :     #if MICROPY_CPYTHON_COMPAT
     679                 :            :     { MP_ROM_QSTR(MP_QSTR_delattr), MP_ROM_PTR(&mp_builtin_delattr_obj) },
     680                 :            :     #endif
     681                 :            :     { MP_ROM_QSTR(MP_QSTR_dir), MP_ROM_PTR(&mp_builtin_dir_obj) },
     682                 :            :     { MP_ROM_QSTR(MP_QSTR_divmod), MP_ROM_PTR(&mp_builtin_divmod_obj) },
     683                 :            :     #if MICROPY_PY_BUILTINS_EVAL_EXEC
     684                 :            :     { MP_ROM_QSTR(MP_QSTR_eval), MP_ROM_PTR(&mp_builtin_eval_obj) },
     685                 :            :     { MP_ROM_QSTR(MP_QSTR_exec), MP_ROM_PTR(&mp_builtin_exec_obj) },
     686                 :            :     #endif
     687                 :            :     #if MICROPY_PY_BUILTINS_EXECFILE
     688                 :            :     { MP_ROM_QSTR(MP_QSTR_execfile), MP_ROM_PTR(&mp_builtin_execfile_obj) },
     689                 :            :     #endif
     690                 :            :     { MP_ROM_QSTR(MP_QSTR_getattr), MP_ROM_PTR(&mp_builtin_getattr_obj) },
     691                 :            :     { MP_ROM_QSTR(MP_QSTR_setattr), MP_ROM_PTR(&mp_builtin_setattr_obj) },
     692                 :            :     { MP_ROM_QSTR(MP_QSTR_globals), MP_ROM_PTR(&mp_builtin_globals_obj) },
     693                 :            :     { MP_ROM_QSTR(MP_QSTR_hasattr), MP_ROM_PTR(&mp_builtin_hasattr_obj) },
     694                 :            :     { MP_ROM_QSTR(MP_QSTR_hash), MP_ROM_PTR(&mp_builtin_hash_obj) },
     695                 :            :     #if MICROPY_PY_BUILTINS_HELP
     696                 :            :     { MP_ROM_QSTR(MP_QSTR_help), MP_ROM_PTR(&mp_builtin_help_obj) },
     697                 :            :     #endif
     698                 :            :     { MP_ROM_QSTR(MP_QSTR_hex), MP_ROM_PTR(&mp_builtin_hex_obj) },
     699                 :            :     { MP_ROM_QSTR(MP_QSTR_id), MP_ROM_PTR(&mp_builtin_id_obj) },
     700                 :            :     #if MICROPY_PY_BUILTINS_INPUT
     701                 :            :     { MP_ROM_QSTR(MP_QSTR_input), MP_ROM_PTR(&mp_builtin_input_obj) },
     702                 :            :     #endif
     703                 :            :     { MP_ROM_QSTR(MP_QSTR_isinstance), MP_ROM_PTR(&mp_builtin_isinstance_obj) },
     704                 :            :     { MP_ROM_QSTR(MP_QSTR_issubclass), MP_ROM_PTR(&mp_builtin_issubclass_obj) },
     705                 :            :     { MP_ROM_QSTR(MP_QSTR_iter), MP_ROM_PTR(&mp_builtin_iter_obj) },
     706                 :            :     { MP_ROM_QSTR(MP_QSTR_len), MP_ROM_PTR(&mp_builtin_len_obj) },
     707                 :            :     { MP_ROM_QSTR(MP_QSTR_locals), MP_ROM_PTR(&mp_builtin_locals_obj) },
     708                 :            :     #if MICROPY_PY_BUILTINS_MIN_MAX
     709                 :            :     { MP_ROM_QSTR(MP_QSTR_max), MP_ROM_PTR(&mp_builtin_max_obj) },
     710                 :            :     { MP_ROM_QSTR(MP_QSTR_min), MP_ROM_PTR(&mp_builtin_min_obj) },
     711                 :            :     #endif
     712                 :            :     { MP_ROM_QSTR(MP_QSTR_next), MP_ROM_PTR(&mp_builtin_next_obj) },
     713                 :            :     { MP_ROM_QSTR(MP_QSTR_oct), MP_ROM_PTR(&mp_builtin_oct_obj) },
     714                 :            :     #if MICROPY_PY_IO
     715                 :            :     { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_builtin_open_obj) },
     716                 :            :     #endif
     717                 :            :     { MP_ROM_QSTR(MP_QSTR_ord), MP_ROM_PTR(&mp_builtin_ord_obj) },
     718                 :            :     { MP_ROM_QSTR(MP_QSTR_pow), MP_ROM_PTR(&mp_builtin_pow_obj) },
     719                 :            :     { MP_ROM_QSTR(MP_QSTR_print), MP_ROM_PTR(&mp_builtin_print_obj) },
     720                 :            :     { MP_ROM_QSTR(MP_QSTR_repr), MP_ROM_PTR(&mp_builtin_repr_obj) },
     721                 :            :     { MP_ROM_QSTR(MP_QSTR_round), MP_ROM_PTR(&mp_builtin_round_obj) },
     722                 :            :     { MP_ROM_QSTR(MP_QSTR_sorted), MP_ROM_PTR(&mp_builtin_sorted_obj) },
     723                 :            :     { MP_ROM_QSTR(MP_QSTR_sum), MP_ROM_PTR(&mp_builtin_sum_obj) },
     724                 :            : 
     725                 :            :     // built-in exceptions
     726                 :            :     { MP_ROM_QSTR(MP_QSTR_BaseException), MP_ROM_PTR(&mp_type_BaseException) },
     727                 :            :     { MP_ROM_QSTR(MP_QSTR_ArithmeticError), MP_ROM_PTR(&mp_type_ArithmeticError) },
     728                 :            :     { MP_ROM_QSTR(MP_QSTR_AssertionError), MP_ROM_PTR(&mp_type_AssertionError) },
     729                 :            :     { MP_ROM_QSTR(MP_QSTR_AttributeError), MP_ROM_PTR(&mp_type_AttributeError) },
     730                 :            :     { MP_ROM_QSTR(MP_QSTR_EOFError), MP_ROM_PTR(&mp_type_EOFError) },
     731                 :            :     { MP_ROM_QSTR(MP_QSTR_Exception), MP_ROM_PTR(&mp_type_Exception) },
     732                 :            :     { MP_ROM_QSTR(MP_QSTR_GeneratorExit), MP_ROM_PTR(&mp_type_GeneratorExit) },
     733                 :            :     { MP_ROM_QSTR(MP_QSTR_ImportError), MP_ROM_PTR(&mp_type_ImportError) },
     734                 :            :     { MP_ROM_QSTR(MP_QSTR_IndentationError), MP_ROM_PTR(&mp_type_IndentationError) },
     735                 :            :     { MP_ROM_QSTR(MP_QSTR_IndexError), MP_ROM_PTR(&mp_type_IndexError) },
     736                 :            :     { MP_ROM_QSTR(MP_QSTR_KeyboardInterrupt), MP_ROM_PTR(&mp_type_KeyboardInterrupt) },
     737                 :            :     { MP_ROM_QSTR(MP_QSTR_KeyError), MP_ROM_PTR(&mp_type_KeyError) },
     738                 :            :     { MP_ROM_QSTR(MP_QSTR_LookupError), MP_ROM_PTR(&mp_type_LookupError) },
     739                 :            :     { MP_ROM_QSTR(MP_QSTR_MemoryError), MP_ROM_PTR(&mp_type_MemoryError) },
     740                 :            :     { MP_ROM_QSTR(MP_QSTR_NameError), MP_ROM_PTR(&mp_type_NameError) },
     741                 :            :     { MP_ROM_QSTR(MP_QSTR_NotImplementedError), MP_ROM_PTR(&mp_type_NotImplementedError) },
     742                 :            :     { MP_ROM_QSTR(MP_QSTR_OSError), MP_ROM_PTR(&mp_type_OSError) },
     743                 :            :     { MP_ROM_QSTR(MP_QSTR_OverflowError), MP_ROM_PTR(&mp_type_OverflowError) },
     744                 :            :     { MP_ROM_QSTR(MP_QSTR_RuntimeError), MP_ROM_PTR(&mp_type_RuntimeError) },
     745                 :            :     #if MICROPY_PY_ASYNC_AWAIT
     746                 :            :     { MP_ROM_QSTR(MP_QSTR_StopAsyncIteration), MP_ROM_PTR(&mp_type_StopAsyncIteration) },
     747                 :            :     #endif
     748                 :            :     { MP_ROM_QSTR(MP_QSTR_StopIteration), MP_ROM_PTR(&mp_type_StopIteration) },
     749                 :            :     { MP_ROM_QSTR(MP_QSTR_SyntaxError), MP_ROM_PTR(&mp_type_SyntaxError) },
     750                 :            :     { MP_ROM_QSTR(MP_QSTR_SystemExit), MP_ROM_PTR(&mp_type_SystemExit) },
     751                 :            :     { MP_ROM_QSTR(MP_QSTR_TypeError), MP_ROM_PTR(&mp_type_TypeError) },
     752                 :            :     #if MICROPY_PY_BUILTINS_STR_UNICODE
     753                 :            :     { MP_ROM_QSTR(MP_QSTR_UnicodeError), MP_ROM_PTR(&mp_type_UnicodeError) },
     754                 :            :     #endif
     755                 :            :     { MP_ROM_QSTR(MP_QSTR_ValueError), MP_ROM_PTR(&mp_type_ValueError) },
     756                 :            :     #if MICROPY_EMIT_NATIVE
     757                 :            :     { MP_ROM_QSTR(MP_QSTR_ViperTypeError), MP_ROM_PTR(&mp_type_ViperTypeError) },
     758                 :            :     #endif
     759                 :            :     { MP_ROM_QSTR(MP_QSTR_ZeroDivisionError), MP_ROM_PTR(&mp_type_ZeroDivisionError) },
     760                 :            : 
     761                 :            :     // Extra builtins as defined by a port
     762                 :            :     MICROPY_PORT_BUILTINS
     763                 :            :     MICROPY_PORT_EXTRA_BUILTINS
     764                 :            : };
     765                 :            : 
     766                 :            : MP_DEFINE_CONST_DICT(mp_module_builtins_globals, mp_module_builtins_globals_table);
     767                 :            : 
     768                 :            : const mp_obj_module_t mp_module_builtins = {
     769                 :            :     .base = { &mp_type_module },
     770                 :            :     .globals = (mp_obj_dict_t *)&mp_module_builtins_globals,
     771                 :            : };
     772                 :            : 
     773                 :            : MP_REGISTER_MODULE(MP_QSTR_builtins, mp_module_builtins);

Generated by: LCOV version 1.15-5-g462f71d