LCOV - code coverage report
Current view: top level - py - objstr.c (source / functions) Hit Total Coverage
Test: unix_coverage_v1.19.1-724-gfb7d21153.info Lines: 1121 1122 99.9 %
Date: 2022-12-01 09:37:31 Functions: 73 73 100.0 %
Branches: 814 876 92.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-2018 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/unicode.h"
      32                 :            : #include "py/objstr.h"
      33                 :            : #include "py/objlist.h"
      34                 :            : #include "py/runtime.h"
      35                 :            : #include "py/stackctrl.h"
      36                 :            : 
      37                 :            : #if MICROPY_PY_BUILTINS_STR_OP_MODULO
      38                 :            : STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_t *args, mp_obj_t dict);
      39                 :            : #endif
      40                 :            : 
      41                 :            : STATIC mp_obj_t mp_obj_new_bytes_iterator(mp_obj_t str, mp_obj_iter_buf_t *iter_buf);
      42                 :            : STATIC NORETURN void bad_implicit_conversion(mp_obj_t self_in);
      43                 :            : 
      44                 :            : STATIC mp_obj_t mp_obj_new_str_type_from_vstr(const mp_obj_type_t *type, vstr_t *vstr);
      45                 :            : 
      46                 :       1616 : STATIC void str_check_arg_type(const mp_obj_type_t *self_type, const mp_obj_t arg) {
      47                 :            :     // String operations generally need the args type to match the object they're called on,
      48                 :            :     // e.g. str.find(str), byte.startswith(byte)
      49                 :            :     // with the exception that bytes may be used for bytearray and vice versa.
      50                 :       1616 :     const mp_obj_type_t *arg_type = mp_obj_get_type(arg);
      51                 :            : 
      52                 :            :     #if MICROPY_PY_BUILTINS_BYTEARRAY
      53         [ -  + ]:       1616 :     if (arg_type == &mp_type_bytearray) {
      54                 :          0 :         arg_type = &mp_type_bytes;
      55                 :            :     }
      56         [ +  + ]:       1616 :     if (self_type == &mp_type_bytearray) {
      57                 :         48 :         self_type = &mp_type_bytes;
      58                 :            :     }
      59                 :            :     #endif
      60                 :            : 
      61         [ +  + ]:       1616 :     if (arg_type != self_type) {
      62                 :         48 :         bad_implicit_conversion(arg);
      63                 :            :     }
      64                 :       1568 : }
      65                 :            : 
      66                 :            : STATIC void check_is_str_or_bytes(mp_obj_t self_in) {
      67                 :            :     mp_check_self(mp_obj_is_str_or_bytes(self_in));
      68                 :            : }
      69                 :            : 
      70                 :            : /******************************************************************************/
      71                 :            : /* str                                                                        */
      72                 :            : 
      73                 :       2552 : void mp_str_print_quoted(const mp_print_t *print, const byte *str_data, size_t str_len, bool is_bytes) {
      74                 :            :     // this escapes characters, but it will be very slow to print (calling print many times)
      75                 :       2552 :     bool has_single_quote = false;
      76                 :       2552 :     bool has_double_quote = false;
      77         [ +  + ]:      24630 :     for (const byte *s = str_data, *top = str_data + str_len; !has_double_quote && s < top; s++) {
      78         [ +  + ]:      22078 :         if (*s == '\'') {
      79                 :            :             has_single_quote = true;
      80         [ +  + ]:      22060 :         } else if (*s == '"') {
      81                 :         16 :             has_double_quote = true;
      82                 :            :         }
      83                 :            :     }
      84                 :       2552 :     int quote_char = '\'';
      85         [ +  + ]:       2552 :     if (has_single_quote && !has_double_quote) {
      86                 :         10 :         quote_char = '"';
      87                 :            :     }
      88                 :       2552 :     mp_printf(print, "%c", quote_char);
      89         [ +  + ]:      26416 :     for (const byte *s = str_data, *top = str_data + str_len; s < top; s++) {
      90         [ +  + ]:      23864 :         if (*s == quote_char) {
      91                 :         16 :             mp_printf(print, "\\%c", quote_char);
      92         [ +  + ]:      23848 :         } else if (*s == '\\') {
      93                 :          6 :             mp_print_str(print, "\\\\");
      94   [ +  +  +  -  :      23842 :         } else if (*s >= 0x20 && *s != 0x7f && (!is_bytes || *s < 0x80)) {
                   +  + ]
      95                 :            :             // In strings, anything which is not ascii control character
      96                 :            :             // is printed as is, this includes characters in range 0x80-0xff
      97                 :            :             // (which can be non-Latin letters, etc.)
      98                 :      15166 :             mp_printf(print, "%c", *s);
      99         [ +  + ]:       8676 :         } else if (*s == '\n') {
     100                 :        166 :             mp_print_str(print, "\\n");
     101         [ +  + ]:       8510 :         } else if (*s == '\r') {
     102                 :         54 :             mp_print_str(print, "\\r");
     103         [ +  + ]:       8456 :         } else if (*s == '\t') {
     104                 :         90 :             mp_print_str(print, "\\t");
     105                 :            :         } else {
     106                 :       8366 :             mp_printf(print, "\\x%02x", *s);
     107                 :            :         }
     108                 :            :     }
     109                 :       2552 :     mp_printf(print, "%c", quote_char);
     110                 :       2552 : }
     111                 :            : 
     112                 :            : #if MICROPY_PY_UJSON
     113                 :        116 : void mp_str_print_json(const mp_print_t *print, const byte *str_data, size_t str_len) {
     114                 :            :     // for JSON spec, see http://www.ietf.org/rfc/rfc4627.txt
     115                 :            :     // if we are given a valid utf8-encoded string, we will print it in a JSON-conforming way
     116                 :        116 :     mp_print_str(print, "\"");
     117         [ +  + ]:        608 :     for (const byte *s = str_data, *top = str_data + str_len; s < top; s++) {
     118         [ +  + ]:        492 :         if (*s == '"' || *s == '\\') {
     119                 :         32 :             mp_printf(print, "\\%c", *s);
     120         [ +  + ]:        460 :         } else if (*s >= 32) {
     121                 :            :             // this will handle normal and utf-8 encoded chars
     122                 :        380 :             mp_printf(print, "%c", *s);
     123         [ +  + ]:         80 :         } else if (*s == '\n') {
     124                 :         16 :             mp_print_str(print, "\\n");
     125         [ +  + ]:         64 :         } else if (*s == '\r') {
     126                 :         16 :             mp_print_str(print, "\\r");
     127         [ +  + ]:         48 :         } else if (*s == '\t') {
     128                 :         16 :             mp_print_str(print, "\\t");
     129                 :            :         } else {
     130                 :            :             // this will handle control chars
     131                 :         32 :             mp_printf(print, "\\u%04x", *s);
     132                 :            :         }
     133                 :            :     }
     134                 :        116 :     mp_print_str(print, "\"");
     135                 :        116 : }
     136                 :            : #endif
     137                 :            : 
     138                 :       1648 : STATIC void str_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     139         [ -  + ]:       1648 :     GET_STR_DATA_LEN(self_in, str_data, str_len);
     140                 :            :     #if MICROPY_PY_UJSON
     141         [ +  + ]:       1648 :     if (kind == PRINT_JSON) {
     142                 :          2 :         mp_str_print_json(print, str_data, str_len);
     143                 :          2 :         return;
     144                 :            :     }
     145                 :            :     #endif
     146                 :            :     #if !MICROPY_PY_BUILTINS_STR_UNICODE
     147                 :            :     bool is_bytes = mp_obj_is_type(self_in, &mp_type_bytes);
     148                 :            :     #else
     149                 :       1646 :     bool is_bytes = true;
     150                 :            :     #endif
     151         [ +  + ]:       1646 :     if (kind == PRINT_RAW || (!MICROPY_PY_BUILTINS_STR_UNICODE && kind == PRINT_STR && !is_bytes)) {
     152                 :          4 :         print->print_strn(print->data, (const char *)str_data, str_len);
     153                 :            :     } else {
     154                 :       1642 :         if (is_bytes) {
     155                 :       1642 :             print->print_strn(print->data, "b", 1);
     156                 :            :         }
     157                 :       1642 :         mp_str_print_quoted(print, str_data, str_len, is_bytes);
     158                 :            :     }
     159                 :            : }
     160                 :            : 
     161                 :      50088 : mp_obj_t mp_obj_str_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     162                 :            :     #if MICROPY_CPYTHON_COMPAT
     163         [ +  + ]:      50088 :     if (n_kw != 0) {
     164                 :          2 :         mp_arg_error_unimpl_kw();
     165                 :            :     }
     166                 :            :     #endif
     167                 :            : 
     168                 :      50086 :     mp_arg_check_num(n_args, n_kw, 0, 3, false);
     169                 :            : 
     170      [ +  +  + ]:      50082 :     switch (n_args) {
     171                 :            :         case 0:
     172                 :            :             return MP_OBJ_NEW_QSTR(MP_QSTR_);
     173                 :            : 
     174                 :      50028 :         case 1: {
     175                 :      50028 :             vstr_t vstr;
     176                 :      50028 :             mp_print_t print;
     177                 :      50028 :             vstr_init_print(&vstr, 16, &print);
     178                 :      50028 :             mp_obj_print_helper(&print, args[0], PRINT_STR);
     179                 :      50028 :             return mp_obj_new_str_type_from_vstr(type, &vstr);
     180                 :            :         }
     181                 :            : 
     182                 :            :         default: // 2 or 3 args
     183                 :            :             // TODO: validate 2nd/3rd args
     184   [ +  -  +  + ]:         50 :             if (mp_obj_is_type(args[0], &mp_type_bytes)) {
     185         [ -  + ]:         24 :                 GET_STR_DATA_LEN(args[0], str_data, str_len);
     186         [ -  + ]:         24 :                 GET_STR_HASH(args[0], str_hash);
     187         [ +  + ]:         24 :                 if (str_hash == 0) {
     188                 :          6 :                     str_hash = qstr_compute_hash(str_data, str_len);
     189                 :            :                 }
     190                 :            :                 #if MICROPY_PY_BUILTINS_STR_UNICODE_CHECK
     191         [ +  + ]:         24 :                 if (!utf8_check(str_data, str_len)) {
     192                 :          6 :                     mp_raise_msg(&mp_type_UnicodeError, NULL);
     193                 :            :                 }
     194                 :            :                 #endif
     195                 :            : 
     196                 :            :                 // Check if a qstr with this data already exists
     197                 :         18 :                 qstr q = qstr_find_strn((const char *)str_data, str_len);
     198         [ +  + ]:         18 :                 if (q != MP_QSTRnull) {
     199                 :          4 :                     return MP_OBJ_NEW_QSTR(q);
     200                 :            :                 }
     201                 :            : 
     202                 :         14 :                 mp_obj_str_t *o = MP_OBJ_TO_PTR(mp_obj_new_str_copy(type, NULL, str_len));
     203                 :         14 :                 o->data = str_data;
     204                 :         14 :                 o->hash = str_hash;
     205                 :         14 :                 return MP_OBJ_FROM_PTR(o);
     206                 :            :             } else {
     207                 :         26 :                 mp_buffer_info_t bufinfo;
     208                 :         26 :                 mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_READ);
     209                 :            :                 // This will utf-8 check the input.
     210                 :         26 :                 return mp_obj_new_str(bufinfo.buf, bufinfo.len);
     211                 :            :             }
     212                 :            :     }
     213                 :            : }
     214                 :            : 
     215                 :        231 : STATIC mp_obj_t bytes_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     216                 :        231 :     (void)type_in;
     217                 :            : 
     218                 :            :     #if MICROPY_CPYTHON_COMPAT
     219         [ +  + ]:        231 :     if (n_kw != 0) {
     220                 :          2 :         mp_arg_error_unimpl_kw();
     221                 :            :     }
     222                 :            :     #else
     223                 :            :     (void)n_kw;
     224                 :            :     #endif
     225                 :            : 
     226         [ +  + ]:        229 :     if (n_args == 0) {
     227                 :            :         return mp_const_empty_bytes;
     228                 :            :     }
     229                 :            : 
     230   [ +  +  +  + ]:        221 :     if (mp_obj_is_type(args[0], &mp_type_bytes)) {
     231                 :            :         return args[0];
     232                 :            :     }
     233                 :            : 
     234   [ +  +  +  +  :        213 :     if (mp_obj_is_str(args[0])) {
                   +  + ]
     235         [ +  + ]:         28 :         if (n_args < 2 || n_args > 3) {
     236                 :            :             #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
     237                 :            :             goto wrong_args;
     238                 :            :             #else
     239                 :          8 :             mp_raise_TypeError(MP_ERROR_TEXT("string argument without an encoding"));
     240                 :            :             #endif
     241                 :            :         }
     242         [ +  + ]:         20 :         GET_STR_DATA_LEN(args[0], str_data, str_len);
     243         [ +  + ]:         20 :         GET_STR_HASH(args[0], str_hash);
     244         [ +  + ]:         20 :         if (str_hash == 0) {
     245                 :          2 :             str_hash = qstr_compute_hash(str_data, str_len);
     246                 :            :         }
     247                 :         20 :         mp_obj_str_t *o = MP_OBJ_TO_PTR(mp_obj_new_str_copy(&mp_type_bytes, NULL, str_len));
     248                 :         20 :         o->data = str_data;
     249                 :         20 :         o->hash = str_hash;
     250                 :         20 :         return MP_OBJ_FROM_PTR(o);
     251                 :            :     }
     252                 :            : 
     253         [ +  + ]:        185 :     if (n_args > 1) {
     254                 :          4 :         goto wrong_args;
     255                 :            :     }
     256                 :            : 
     257         [ +  + ]:        181 :     if (mp_obj_is_small_int(args[0])) {
     258                 :         20 :         mp_int_t len = MP_OBJ_SMALL_INT_VALUE(args[0]);
     259         [ +  + ]:         20 :         if (len < 0) {
     260                 :          4 :             mp_raise_ValueError(NULL);
     261                 :            :         }
     262                 :         16 :         vstr_t vstr;
     263                 :         16 :         vstr_init_len(&vstr, len);
     264                 :         16 :         memset(vstr.buf, 0, len);
     265                 :         16 :         return mp_obj_new_bytes_from_vstr(&vstr);
     266                 :            :     }
     267                 :            : 
     268                 :            :     // check if argument has the buffer protocol
     269                 :        161 :     mp_buffer_info_t bufinfo;
     270         [ +  + ]:        161 :     if (mp_get_buffer(args[0], &bufinfo, MP_BUFFER_READ)) {
     271                 :         68 :         return mp_obj_new_bytes(bufinfo.buf, bufinfo.len);
     272                 :            :     }
     273                 :            : 
     274                 :         93 :     vstr_t vstr;
     275                 :            :     // Try to create array of exact len if initializer len is known
     276                 :         93 :     mp_obj_t len_in = mp_obj_len_maybe(args[0]);
     277         [ +  + ]:         93 :     if (len_in == MP_OBJ_NULL) {
     278                 :         12 :         vstr_init(&vstr, 16);
     279                 :            :     } else {
     280                 :         81 :         mp_int_t len = MP_OBJ_SMALL_INT_VALUE(len_in);
     281                 :         81 :         vstr_init(&vstr, len);
     282                 :            :     }
     283                 :            : 
     284                 :         93 :     mp_obj_iter_buf_t iter_buf;
     285                 :         93 :     mp_obj_t iterable = mp_getiter(args[0], &iter_buf);
     286                 :         93 :     mp_obj_t item;
     287         [ +  + ]:       1321 :     while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
     288                 :       1236 :         mp_int_t val = mp_obj_get_int(item);
     289                 :            :         #if MICROPY_FULL_CHECKS
     290         [ +  + ]:       1236 :         if (val < 0 || val > 255) {
     291                 :          8 :             mp_raise_ValueError(MP_ERROR_TEXT("bytes value out of range"));
     292                 :            :         }
     293                 :            :         #endif
     294                 :       1228 :         vstr_add_byte(&vstr, val);
     295                 :            :     }
     296                 :            : 
     297                 :         81 :     return mp_obj_new_bytes_from_vstr(&vstr);
     298                 :            : 
     299                 :          4 : wrong_args:
     300                 :          4 :     mp_raise_TypeError(MP_ERROR_TEXT("wrong number of arguments"));
     301                 :            : }
     302                 :            : 
     303                 :            : // like strstr but with specified length and allows \0 bytes
     304                 :            : // TODO replace with something more efficient/standard
     305                 :       2330 : const byte *find_subbytes(const byte *haystack, size_t hlen, const byte *needle, size_t nlen, int direction) {
     306         [ +  + ]:       2330 :     if (hlen >= nlen) {
     307                 :       1866 :         size_t str_index, str_index_end;
     308         [ +  + ]:       1866 :         if (direction > 0) {
     309                 :       1670 :             str_index = 0;
     310                 :       1670 :             str_index_end = hlen - nlen;
     311                 :            :         } else {
     312                 :        196 :             str_index = hlen - nlen;
     313                 :        196 :             str_index_end = 0;
     314                 :            :         }
     315                 :     288418 :         for (;;) {
     316         [ +  + ]:     145142 :             if (memcmp(&haystack[str_index], needle, nlen) == 0) {
     317                 :            :                 // found
     318                 :            :                 return haystack + str_index;
     319                 :            :             }
     320         [ +  + ]:     143670 :             if (str_index == str_index_end) {
     321                 :            :                 // not found
     322                 :            :                 break;
     323                 :            :             }
     324                 :     143276 :             str_index += direction;
     325                 :            :         }
     326                 :            :     }
     327                 :            :     return NULL;
     328                 :            : }
     329                 :            : 
     330                 :            : // Note: this function is used to check if an object is a str or bytes, which
     331                 :            : // works because both those types use it as their binary_op method.  Revisit
     332                 :            : // mp_obj_is_str_or_bytes if this fact changes.
     333                 :     196708 : mp_obj_t mp_obj_str_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
     334                 :            :     // check for modulo
     335         [ +  + ]:     196708 :     if (op == MP_BINARY_OP_MODULO) {
     336                 :            :         #if MICROPY_PY_BUILTINS_STR_OP_MODULO
     337                 :      85290 :         mp_obj_t *args = &rhs_in;
     338                 :      85290 :         size_t n_args = 1;
     339                 :      85290 :         mp_obj_t dict = MP_OBJ_NULL;
     340   [ -  +  -  +  :      85290 :         if (mp_obj_is_type(rhs_in, &mp_type_tuple)) {
          -  +  -  +  +  
                +  +  + ]
     341                 :            :             // TODO: Support tuple subclasses?
     342                 :       4858 :             mp_obj_tuple_get(rhs_in, &n_args, &args);
     343   [ -  +  -  +  :      80432 :         } else if (mp_obj_is_type(rhs_in, &mp_type_dict)) {
          -  +  -  +  +  
                +  +  + ]
     344                 :         34 :             dict = rhs_in;
     345                 :            :         }
     346                 :      85290 :         return str_modulo_format(lhs_in, n_args, args, dict);
     347                 :            :         #else
     348                 :            :         return MP_OBJ_NULL;
     349                 :            :         #endif
     350                 :            :     }
     351                 :            : 
     352                 :            :     // from now on we need lhs type and data, so extract them
     353                 :     111418 :     const mp_obj_type_t *lhs_type = mp_obj_get_type(lhs_in);
     354         [ +  + ]:     111418 :     GET_STR_DATA_LEN(lhs_in, lhs_data, lhs_len);
     355                 :            : 
     356                 :            :     // check for multiply
     357         [ +  + ]:     111418 :     if (op == MP_BINARY_OP_MULTIPLY) {
     358                 :        312 :         mp_int_t n;
     359         [ +  + ]:        312 :         if (!mp_obj_get_int_maybe(rhs_in, &n)) {
     360                 :            :             return MP_OBJ_NULL; // op not supported
     361                 :            :         }
     362         [ +  + ]:        308 :         if (n <= 0) {
     363         [ +  + ]:         48 :             if (lhs_type == &mp_type_str) {
     364                 :            :                 return MP_OBJ_NEW_QSTR(MP_QSTR_); // empty str
     365                 :            :             } else {
     366                 :         24 :                 return mp_const_empty_bytes;
     367                 :            :             }
     368                 :            :         }
     369                 :        260 :         vstr_t vstr;
     370                 :        260 :         vstr_init_len(&vstr, lhs_len * n);
     371                 :        260 :         mp_seq_multiply(lhs_data, sizeof(*lhs_data), lhs_len, n, vstr.buf);
     372                 :        260 :         return mp_obj_new_str_type_from_vstr(lhs_type, &vstr);
     373                 :            :     }
     374                 :            : 
     375                 :            :     // From now on all operations allow:
     376                 :            :     //    - str with str
     377                 :            :     //    - bytes with bytes
     378                 :            :     //    - bytes with bytearray
     379                 :            :     //    - bytes with array.array
     380                 :            :     // To do this efficiently we use the buffer protocol to extract the raw
     381                 :            :     // data for the rhs, but only if the lhs is a bytes object.
     382                 :            :     //
     383                 :            :     // NOTE: CPython does not allow comparison between bytes ard array.array
     384                 :            :     // (even if the array is of type 'b'), even though it allows addition of
     385                 :            :     // such types.  We are not compatible with this (we do allow comparison
     386                 :            :     // of bytes with anything that has the buffer protocol).  It would be
     387                 :            :     // easy to "fix" this with a bit of extra logic below, but it costs code
     388                 :            :     // size and execution time so we don't.
     389                 :            : 
     390                 :     111106 :     const byte *rhs_data;
     391                 :     111106 :     size_t rhs_len;
     392         [ +  + ]:     111106 :     if (lhs_type == mp_obj_get_type(rhs_in)) {
     393         [ +  + ]:     110552 :         GET_STR_DATA_LEN(rhs_in, rhs_data_, rhs_len_);
     394                 :     110552 :         rhs_data = rhs_data_;
     395                 :     110552 :         rhs_len = rhs_len_;
     396         [ +  + ]:        554 :     } else if (lhs_type == &mp_type_bytes) {
     397                 :        546 :         mp_buffer_info_t bufinfo;
     398         [ +  + ]:        546 :         if (!mp_get_buffer(rhs_in, &bufinfo, MP_BUFFER_READ)) {
     399                 :         22 :             return MP_OBJ_NULL; // op not supported
     400                 :            :         }
     401                 :        524 :         rhs_data = bufinfo.buf;
     402                 :        524 :         rhs_len = bufinfo.len;
     403                 :            :     } else {
     404                 :            :         // LHS is str and RHS has an incompatible type
     405                 :            :         // (except if operation is EQUAL, but that's handled by mp_obj_equal)
     406                 :          8 :         bad_implicit_conversion(rhs_in);
     407                 :            :     }
     408                 :            : 
     409   [ +  +  +  + ]:     111076 :     switch (op) {
     410                 :      81794 :         case MP_BINARY_OP_ADD:
     411                 :            :         case MP_BINARY_OP_INPLACE_ADD: {
     412   [ +  +  +  + ]:      81794 :             if (lhs_len == 0 && mp_obj_get_type(rhs_in) == lhs_type) {
     413                 :         24 :                 return rhs_in;
     414                 :            :             }
     415         [ +  + ]:      81770 :             if (rhs_len == 0) {
     416                 :            :                 return lhs_in;
     417                 :            :             }
     418                 :            : 
     419                 :      73550 :             vstr_t vstr;
     420                 :      73550 :             vstr_init_len(&vstr, lhs_len + rhs_len);
     421                 :      73550 :             memcpy(vstr.buf, lhs_data, lhs_len);
     422                 :      73550 :             memcpy(vstr.buf + lhs_len, rhs_data, rhs_len);
     423                 :      73550 :             return mp_obj_new_str_type_from_vstr(lhs_type, &vstr);
     424                 :            :         }
     425                 :            : 
     426                 :        648 :         case MP_BINARY_OP_CONTAINS:
     427         [ +  + ]:        648 :             return mp_obj_new_bool(find_subbytes(lhs_data, lhs_len, rhs_data, rhs_len, 1) != NULL);
     428                 :            : 
     429                 :            :         // case MP_BINARY_OP_NOT_EQUAL: // This is never passed here
     430                 :      28624 :         case MP_BINARY_OP_EQUAL: // This will be passed only for bytes, str is dealt with in mp_obj_equal()
     431                 :            :         case MP_BINARY_OP_LESS:
     432                 :            :         case MP_BINARY_OP_LESS_EQUAL:
     433                 :            :         case MP_BINARY_OP_MORE:
     434                 :            :         case MP_BINARY_OP_MORE_EQUAL:
     435         [ +  + ]:      28624 :             return mp_obj_new_bool(mp_seq_cmp_bytes(op, lhs_data, lhs_len, rhs_data, rhs_len));
     436                 :            : 
     437                 :            :         default:
     438                 :            :             return MP_OBJ_NULL; // op not supported
     439                 :            :     }
     440                 :            : }
     441                 :            : 
     442                 :            : #if !MICROPY_PY_BUILTINS_STR_UNICODE
     443                 :            : // objstrunicode defines own version
     444                 :            : const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, size_t self_len,
     445                 :            :     mp_obj_t index, bool is_slice) {
     446                 :            :     size_t index_val = mp_get_index(type, self_len, index, is_slice);
     447                 :            :     return self_data + index_val;
     448                 :            : }
     449                 :            : #endif
     450                 :            : 
     451                 :            : // This is used for both bytes and 8-bit strings. This is not used for unicode strings.
     452                 :    2612328 : STATIC mp_obj_t bytes_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
     453                 :    2612328 :     const mp_obj_type_t *type = mp_obj_get_type(self_in);
     454         [ -  + ]:    2651676 :     GET_STR_DATA_LEN(self_in, self_data, self_len);
     455         [ +  + ]:    2651676 :     if (value == MP_OBJ_SENTINEL) {
     456                 :            :         // load
     457                 :            :         #if MICROPY_PY_BUILTINS_SLICE
     458   [ -  +  -  +  :    2651668 :         if (mp_obj_is_type(index, &mp_type_slice)) {
          -  +  -  +  +  
                +  +  - ]
     459                 :          6 :             mp_bound_slice_t slice;
     460         [ +  + ]:          6 :             if (!mp_seq_get_fast_slice_indexes(self_len, index, &slice)) {
     461                 :          2 :                 mp_raise_NotImplementedError(MP_ERROR_TEXT("only slices with step=1 (aka None) are supported"));
     462                 :            :             }
     463                 :          4 :             return mp_obj_new_str_of_type(type, self_data + slice.start, slice.stop - slice.start);
     464                 :            :         }
     465                 :            :         #endif
     466                 :    2651662 :         size_t index_val = mp_get_index(type, self_len, index, false);
     467                 :            :         // If we have unicode enabled the type will always be bytes, so take the short cut.
     468                 :    2675931 :         if (MICROPY_PY_BUILTINS_STR_UNICODE || type == &mp_type_bytes) {
     469                 :    2675931 :             return MP_OBJ_NEW_SMALL_INT(self_data[index_val]);
     470                 :            :         } else {
     471                 :            :             return mp_obj_new_str_via_qstr((char *)&self_data[index_val], 1);
     472                 :            :         }
     473                 :            :     } else {
     474                 :            :         return MP_OBJ_NULL; // op not supported
     475                 :            :     }
     476                 :            : }
     477                 :            : 
     478                 :        412 : STATIC mp_obj_t str_join(mp_obj_t self_in, mp_obj_t arg) {
     479                 :        412 :     check_is_str_or_bytes(self_in);
     480                 :        412 :     const mp_obj_type_t *self_type = mp_obj_get_type(self_in);
     481                 :        412 :     const mp_obj_type_t *ret_type = self_type;
     482                 :            : 
     483                 :            :     // get separation string
     484         [ +  + ]:        412 :     GET_STR_DATA_LEN(self_in, sep_str, sep_len);
     485                 :            : 
     486                 :            :     // process args
     487                 :        412 :     size_t seq_len;
     488                 :        412 :     mp_obj_t *seq_items;
     489                 :            : 
     490   [ -  +  -  +  :        412 :     if (!mp_obj_is_type(arg, &mp_type_list) && !mp_obj_is_type(arg, &mp_type_tuple)) {
          -  +  -  +  +  
          +  +  +  -  +  
          -  +  -  +  -  
             +  +  +  +  
                      + ]
     491                 :            :         // arg is not a list nor a tuple, try to convert it to a list
     492                 :            :         // TODO: Try to optimize?
     493                 :        194 :         arg = mp_obj_list_make_new(&mp_type_list, 1, 0, &arg);
     494                 :            :     }
     495                 :        408 :     mp_obj_get_array(arg, &seq_len, &seq_items);
     496                 :            : 
     497                 :            :     // count required length
     498                 :        408 :     size_t required_len = 0;
     499                 :            :     #if MICROPY_PY_BUILTINS_BYTEARRAY
     500         [ +  + ]:        408 :     if (self_type == &mp_type_bytearray) {
     501                 :          8 :         self_type = &mp_type_bytes;
     502                 :            :     }
     503                 :            :     #endif
     504         [ +  + ]:      25224 :     for (size_t i = 0; i < seq_len; i++) {
     505                 :      24824 :         const mp_obj_type_t *seq_type = mp_obj_get_type(seq_items[i]);
     506                 :            :         #if MICROPY_PY_BUILTINS_BYTEARRAY
     507         [ +  + ]:      24824 :         if (seq_type == &mp_type_bytearray) {
     508                 :          8 :             seq_type = &mp_type_bytes;
     509                 :            :         }
     510                 :            :         #endif
     511         [ +  + ]:      24824 :         if (seq_type != self_type) {
     512                 :          8 :             mp_raise_TypeError(
     513                 :          8 :                 MP_ERROR_TEXT("join expects a list of str/bytes objects consistent with self object"));
     514                 :            :         }
     515         [ +  + ]:      24816 :         if (i > 0) {
     516                 :      24428 :             required_len += sep_len;
     517                 :            :         }
     518         [ +  + ]:      24816 :         GET_STR_LEN(seq_items[i], l);
     519                 :      24816 :         required_len += l;
     520                 :            :     }
     521                 :            : 
     522                 :            :     // make joined string
     523                 :        400 :     vstr_t vstr;
     524                 :        400 :     vstr_init_len(&vstr, required_len);
     525                 :        400 :     byte *data = (byte *)vstr.buf;
     526         [ +  + ]:      25216 :     for (size_t i = 0; i < seq_len; i++) {
     527         [ +  + ]:      24816 :         if (i > 0) {
     528                 :      24428 :             memcpy(data, sep_str, sep_len);
     529                 :      24428 :             data += sep_len;
     530                 :            :         }
     531         [ +  + ]:      24816 :         GET_STR_DATA_LEN(seq_items[i], s, l);
     532                 :      24816 :         memcpy(data, s, l);
     533                 :      24816 :         data += l;
     534                 :            :     }
     535                 :            : 
     536                 :            :     // return joined string
     537                 :        400 :     return mp_obj_new_str_type_from_vstr(ret_type, &vstr);
     538                 :            : }
     539                 :            : MP_DEFINE_CONST_FUN_OBJ_2(str_join_obj, str_join);
     540                 :            : 
     541                 :        313 : mp_obj_t mp_obj_str_split(size_t n_args, const mp_obj_t *args) {
     542                 :        313 :     const mp_obj_type_t *self_type = mp_obj_get_type(args[0]);
     543                 :        313 :     mp_int_t splits = -1;
     544                 :        313 :     mp_obj_t sep = mp_const_none;
     545         [ +  + ]:        313 :     if (n_args > 1) {
     546                 :        289 :         sep = args[1];
     547         [ +  + ]:        289 :         if (n_args > 2) {
     548                 :         76 :             splits = mp_obj_get_int(args[2]);
     549                 :            :         }
     550                 :            :     }
     551                 :            : 
     552                 :        313 :     mp_obj_t res = mp_obj_new_list(0, NULL);
     553         [ +  + ]:        313 :     GET_STR_DATA_LEN(args[0], s, len);
     554                 :        313 :     const byte *top = s + len;
     555                 :            : 
     556         [ +  + ]:        313 :     if (sep == mp_const_none) {
     557                 :            :         // sep not given, so separate on whitespace
     558                 :            : 
     559                 :            :         // Initial whitespace is not counted as split, so we pre-do it
     560   [ +  -  +  + ]:        216 :         while (s < top && unichar_isspace(*s)) {
     561                 :        144 :             s++;
     562                 :            :         }
     563         [ +  + ]:        176 :         while (s < top && splits != 0) {
     564                 :            :             const byte *start = s;
     565   [ +  +  +  + ]:        296 :             while (s < top && !unichar_isspace(*s)) {
     566                 :        172 :                 s++;
     567                 :            :             }
     568                 :        124 :             mp_obj_list_append(res, mp_obj_new_str_of_type(self_type, start, s - start));
     569         [ +  + ]:        124 :             if (s >= top) {
     570                 :            :                 break;
     571                 :            :             }
     572   [ +  +  +  + ]:        360 :             while (s < top && unichar_isspace(*s)) {
     573                 :        256 :                 s++;
     574                 :            :             }
     575         [ +  + ]:        104 :             if (splits > 0) {
     576                 :         32 :                 splits--;
     577                 :            :             }
     578                 :            :         }
     579                 :            : 
     580         [ +  + ]:         72 :         if (s < top) {
     581                 :         24 :             mp_obj_list_append(res, mp_obj_new_str_of_type(self_type, s, top - s));
     582                 :            :         }
     583                 :            : 
     584                 :            :     } else {
     585                 :            :         // sep given
     586                 :        241 :         str_check_arg_type(self_type, sep);
     587                 :            : 
     588                 :        237 :         size_t sep_len;
     589                 :        237 :         const char *sep_str = mp_obj_str_get_data(sep, &sep_len);
     590                 :            : 
     591         [ +  + ]:        237 :         if (sep_len == 0) {
     592                 :         12 :             mp_raise_ValueError(MP_ERROR_TEXT("empty separator"));
     593                 :            :         }
     594                 :            : 
     595                 :        580 :         for (;;) {
     596                 :        580 :             const byte *start = s;
     597                 :      13288 :             for (;;) {
     598   [ +  +  +  + ]:       6934 :                 if (splits == 0 || s + sep_len > top) {
     599                 :            :                     s = top;
     600                 :            :                     break;
     601         [ +  + ]:       6709 :                 } else if (memcmp(s, sep_str, sep_len) == 0) {
     602                 :            :                     break;
     603                 :            :                 }
     604                 :       6354 :                 s++;
     605                 :            :             }
     606                 :        580 :             mp_obj_list_append(res, mp_obj_new_str_of_type(self_type, start, s - start));
     607         [ +  + ]:        580 :             if (s >= top) {
     608                 :            :                 break;
     609                 :            :             }
     610                 :        355 :             s += sep_len;
     611         [ +  + ]:        355 :             if (splits > 0) {
     612                 :         32 :                 splits--;
     613                 :            :             }
     614                 :            :         }
     615                 :            :     }
     616                 :            : 
     617                 :        297 :     return res;
     618                 :            : }
     619                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_split_obj, 1, 3, mp_obj_str_split);
     620                 :            : 
     621                 :            : #if MICROPY_PY_BUILTINS_STR_SPLITLINES
     622                 :         80 : STATIC mp_obj_t str_splitlines(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     623                 :         80 :     enum { ARG_keepends };
     624                 :         80 :     static const mp_arg_t allowed_args[] = {
     625                 :            :         { MP_QSTR_keepends, MP_ARG_BOOL, {.u_bool = false} },
     626                 :            :     };
     627                 :            : 
     628                 :            :     // parse args
     629                 :         80 :     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     630                 :         80 :     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
     631                 :            : 
     632                 :         80 :     const mp_obj_type_t *self_type = mp_obj_get_type(pos_args[0]);
     633                 :         80 :     mp_obj_t res = mp_obj_new_list(0, NULL);
     634                 :            : 
     635         [ +  + ]:         80 :     GET_STR_DATA_LEN(pos_args[0], s, len);
     636                 :         80 :     const byte *top = s + len;
     637                 :            : 
     638         [ +  + ]:        288 :     while (s < top) {
     639                 :            :         const byte *start = s;
     640                 :        736 :         size_t match = 0;
     641         [ +  + ]:        736 :         while (s < top) {
     642         [ +  + ]:        716 :             if (*s == '\n') {
     643                 :            :                 match = 1;
     644                 :            :                 break;
     645         [ +  + ]:        620 :             } else if (*s == '\r') {
     646         [ +  + ]:         92 :                 if (s[1] == '\n') {
     647                 :            :                     match = 2;
     648                 :            :                 } else {
     649                 :         40 :                     match = 1;
     650                 :            :                 }
     651                 :            :                 break;
     652                 :            :             }
     653                 :        528 :             s++;
     654                 :            :         }
     655                 :        208 :         size_t sub_len = s - start;
     656         [ +  + ]:        208 :         if (args[ARG_keepends].u_bool) {
     657                 :         80 :             sub_len += match;
     658                 :            :         }
     659                 :        208 :         mp_obj_list_append(res, mp_obj_new_str_of_type(self_type, start, sub_len));
     660                 :        208 :         s += match;
     661                 :            :     }
     662                 :            : 
     663                 :         80 :     return res;
     664                 :            : }
     665                 :            : MP_DEFINE_CONST_FUN_OBJ_KW(str_splitlines_obj, 1, str_splitlines);
     666                 :            : #endif
     667                 :            : 
     668                 :        124 : STATIC mp_obj_t str_rsplit(size_t n_args, const mp_obj_t *args) {
     669         [ +  + ]:        124 :     if (n_args < 3) {
     670                 :            :         // If we don't have split limit, it doesn't matter from which side
     671                 :            :         // we split.
     672                 :         52 :         return mp_obj_str_split(n_args, args);
     673                 :            :     }
     674                 :         72 :     const mp_obj_type_t *self_type = mp_obj_get_type(args[0]);
     675                 :         72 :     mp_obj_t sep = args[1];
     676         [ +  + ]:         72 :     GET_STR_DATA_LEN(args[0], s, len);
     677                 :            : 
     678                 :         72 :     mp_int_t splits = mp_obj_get_int(args[2]);
     679         [ +  + ]:         72 :     if (splits < 0) {
     680                 :            :         // Negative limit means no limit, so delegate to split().
     681                 :          8 :         return mp_obj_str_split(n_args, args);
     682                 :            :     }
     683                 :            : 
     684                 :         64 :     mp_int_t org_splits = splits;
     685                 :            :     // Preallocate list to the max expected # of elements, as we
     686                 :            :     // will fill it from the end.
     687                 :         64 :     mp_obj_list_t *res = MP_OBJ_TO_PTR(mp_obj_new_list(splits + 1, NULL));
     688                 :         64 :     mp_int_t idx = splits;
     689                 :            : 
     690         [ +  + ]:         64 :     if (sep == mp_const_none) {
     691                 :          2 :         mp_raise_NotImplementedError(MP_ERROR_TEXT("rsplit(None,n)"));
     692                 :            :     } else {
     693                 :         62 :         size_t sep_len;
     694                 :         62 :         const char *sep_str = mp_obj_str_get_data(sep, &sep_len);
     695                 :            : 
     696         [ +  + ]:         62 :         if (sep_len == 0) {
     697                 :          4 :             mp_raise_ValueError(MP_ERROR_TEXT("empty separator"));
     698                 :            :         }
     699                 :            : 
     700                 :         58 :         const byte *beg = s;
     701                 :         58 :         const byte *last = s + len;
     702                 :        286 :         for (;;) {
     703                 :        172 :             s = last - sep_len;
     704                 :        572 :             for (;;) {
     705         [ +  + ]:        372 :                 if (splits == 0 || s < beg) {
     706                 :            :                     break;
     707         [ +  + ]:        314 :                 } else if (memcmp(s, sep_str, sep_len) == 0) {
     708                 :            :                     break;
     709                 :            :                 }
     710                 :        200 :                 s--;
     711                 :            :             }
     712         [ +  + ]:        172 :             if (s < beg || splits == 0) {
     713                 :         58 :                 res->items[idx] = mp_obj_new_str_of_type(self_type, beg, last - beg);
     714                 :         58 :                 break;
     715                 :            :             }
     716                 :        114 :             res->items[idx--] = mp_obj_new_str_of_type(self_type, s + sep_len, last - s - sep_len);
     717                 :        114 :             last = s;
     718                 :        114 :             splits--;
     719                 :            :         }
     720         [ +  + ]:         58 :         if (idx != 0) {
     721                 :            :             // We split less parts than split limit, now go cleanup surplus
     722                 :         16 :             size_t used = org_splits + 1 - idx;
     723                 :         16 :             memmove(res->items, &res->items[idx], used * sizeof(mp_obj_t));
     724                 :         16 :             mp_seq_clear(res->items, used, res->alloc, sizeof(*res->items));
     725                 :         16 :             res->len = used;
     726                 :            :         }
     727                 :            :     }
     728                 :            : 
     729                 :         58 :     return MP_OBJ_FROM_PTR(res);
     730                 :            : }
     731                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_rsplit_obj, 1, 3, str_rsplit);
     732                 :            : 
     733                 :        526 : STATIC mp_obj_t str_finder(size_t n_args, const mp_obj_t *args, int direction, bool is_index) {
     734                 :        526 :     const mp_obj_type_t *self_type = mp_obj_get_type(args[0]);
     735                 :        526 :     check_is_str_or_bytes(args[0]);
     736                 :            : 
     737                 :            :     // check argument type
     738                 :        526 :     str_check_arg_type(self_type, args[1]);
     739                 :            : 
     740         [ +  + ]:        522 :     GET_STR_DATA_LEN(args[0], haystack, haystack_len);
     741         [ +  + ]:        522 :     GET_STR_DATA_LEN(args[1], needle, needle_len);
     742                 :            : 
     743                 :        522 :     const byte *start = haystack;
     744                 :        522 :     const byte *end = haystack + haystack_len;
     745   [ +  +  +  + ]:        522 :     if (n_args >= 3 && args[2] != mp_const_none) {
     746                 :        412 :         start = str_index_to_ptr(self_type, haystack, haystack_len, args[2], true);
     747                 :            :     }
     748   [ +  +  +  + ]:        452 :     if (n_args >= 4 && args[3] != mp_const_none) {
     749                 :        130 :         end = str_index_to_ptr(self_type, haystack, haystack_len, args[3], true);
     750                 :            :     }
     751                 :            : 
     752         [ +  + ]:        522 :     if (end < start) {
     753                 :          8 :         goto out_error;
     754                 :            :     }
     755                 :            : 
     756                 :        514 :     const byte *p = find_subbytes(start, end - start, needle, needle_len, direction);
     757         [ +  + ]:        514 :     if (p == NULL) {
     758                 :        184 :     out_error:
     759                 :            :         // not found
     760         [ +  + ]:        192 :         if (is_index) {
     761                 :         72 :             mp_raise_ValueError(MP_ERROR_TEXT("substring not found"));
     762                 :            :         } else {
     763                 :            :             return MP_OBJ_NEW_SMALL_INT(-1);
     764                 :            :         }
     765                 :            :     } else {
     766                 :            :         // found
     767                 :            :         #if MICROPY_PY_BUILTINS_STR_UNICODE
     768         [ +  + ]:        330 :         if (self_type == &mp_type_str) {
     769                 :        262 :             return MP_OBJ_NEW_SMALL_INT(utf8_ptr_to_index(haystack, p));
     770                 :            :         }
     771                 :            :         #endif
     772                 :         68 :         return MP_OBJ_NEW_SMALL_INT(p - haystack);
     773                 :            :     }
     774                 :            : }
     775                 :            : 
     776                 :        218 : STATIC mp_obj_t str_find(size_t n_args, const mp_obj_t *args) {
     777                 :        218 :     return str_finder(n_args, args, 1, false);
     778                 :            : }
     779                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_find_obj, 2, 4, str_find);
     780                 :            : 
     781                 :        104 : STATIC mp_obj_t str_rfind(size_t n_args, const mp_obj_t *args) {
     782                 :        104 :     return str_finder(n_args, args, -1, false);
     783                 :            : }
     784                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_rfind_obj, 2, 4, str_rfind);
     785                 :            : 
     786                 :        104 : STATIC mp_obj_t str_index(size_t n_args, const mp_obj_t *args) {
     787                 :        104 :     return str_finder(n_args, args, 1, true);
     788                 :            : }
     789                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_index_obj, 2, 4, str_index);
     790                 :            : 
     791                 :        100 : STATIC mp_obj_t str_rindex(size_t n_args, const mp_obj_t *args) {
     792                 :        100 :     return str_finder(n_args, args, -1, true);
     793                 :            : }
     794                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_rindex_obj, 2, 4, str_rindex);
     795                 :            : 
     796                 :            : // TODO: (Much) more variety in args
     797                 :        253 : STATIC mp_obj_t str_startswith(size_t n_args, const mp_obj_t *args) {
     798                 :        253 :     const mp_obj_type_t *self_type = mp_obj_get_type(args[0]);
     799         [ +  + ]:        253 :     GET_STR_DATA_LEN(args[0], str, str_len);
     800                 :        253 :     size_t prefix_len;
     801                 :        253 :     const char *prefix = mp_obj_str_get_data(args[1], &prefix_len);
     802                 :        245 :     const byte *start = str;
     803         [ +  + ]:        245 :     if (n_args > 2) {
     804                 :         26 :         start = str_index_to_ptr(self_type, str, str_len, args[2], true);
     805                 :            :     }
     806         [ +  + ]:        245 :     if (prefix_len + (start - str) > str_len) {
     807                 :            :         return mp_const_false;
     808                 :            :     }
     809         [ +  + ]:        189 :     return mp_obj_new_bool(memcmp(start, prefix, prefix_len) == 0);
     810                 :            : }
     811                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_startswith_obj, 2, 3, str_startswith);
     812                 :            : 
     813                 :         38 : STATIC mp_obj_t str_endswith(size_t n_args, const mp_obj_t *args) {
     814         [ +  + ]:         38 :     GET_STR_DATA_LEN(args[0], str, str_len);
     815                 :         38 :     size_t suffix_len;
     816                 :         38 :     const char *suffix = mp_obj_str_get_data(args[1], &suffix_len);
     817         [ +  + ]:         30 :     if (n_args > 2) {
     818                 :          2 :         mp_raise_NotImplementedError(MP_ERROR_TEXT("start/end indices"));
     819                 :            :     }
     820                 :            : 
     821         [ +  + ]:         28 :     if (suffix_len > str_len) {
     822                 :            :         return mp_const_false;
     823                 :            :     }
     824         [ +  + ]:         24 :     return mp_obj_new_bool(memcmp(str + (str_len - suffix_len), suffix, suffix_len) == 0);
     825                 :            : }
     826                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_endswith_obj, 2, 3, str_endswith);
     827                 :            : 
     828                 :            : enum { LSTRIP, RSTRIP, STRIP };
     829                 :            : 
     830                 :        172 : STATIC mp_obj_t str_uni_strip(int type, size_t n_args, const mp_obj_t *args) {
     831                 :        172 :     check_is_str_or_bytes(args[0]);
     832                 :        172 :     const mp_obj_type_t *self_type = mp_obj_get_type(args[0]);
     833                 :            : 
     834                 :        172 :     const byte *chars_to_del;
     835                 :        172 :     uint chars_to_del_len;
     836                 :        172 :     static const byte whitespace[] = " \t\n\r\v\f";
     837                 :            : 
     838         [ +  + ]:        172 :     if (n_args == 1) {
     839                 :            :         chars_to_del = whitespace;
     840                 :            :         chars_to_del_len = sizeof(whitespace) - 1;
     841                 :            :     } else {
     842                 :         68 :         str_check_arg_type(self_type, args[1]);
     843         [ +  + ]:         60 :         GET_STR_DATA_LEN(args[1], s, l);
     844                 :         60 :         chars_to_del = s;
     845                 :         60 :         chars_to_del_len = l;
     846                 :            :     }
     847                 :            : 
     848         [ +  + ]:        164 :     GET_STR_DATA_LEN(args[0], orig_str, orig_str_len);
     849                 :            : 
     850                 :        164 :     size_t first_good_char_pos = 0;
     851                 :        164 :     bool first_good_char_pos_set = false;
     852                 :        164 :     size_t last_good_char_pos = 0;
     853                 :        164 :     size_t i = 0;
     854                 :        164 :     int delta = 1;
     855         [ +  + ]:        164 :     if (type == RSTRIP) {
     856                 :         44 :         i = orig_str_len - 1;
     857                 :         44 :         delta = -1;
     858                 :            :     }
     859         [ +  + ]:        732 :     for (size_t len = orig_str_len; len > 0; len--) {
     860         [ +  + ]:        652 :         if (find_subbytes(chars_to_del, chars_to_del_len, &orig_str[i], 1, 1) == NULL) {
     861         [ +  + ]:        288 :             if (!first_good_char_pos_set) {
     862                 :        148 :                 first_good_char_pos_set = true;
     863                 :        148 :                 first_good_char_pos = i;
     864         [ +  + ]:        148 :                 if (type == LSTRIP) {
     865                 :         40 :                     last_good_char_pos = orig_str_len - 1;
     866                 :         40 :                     break;
     867         [ +  + ]:        108 :                 } else if (type == RSTRIP) {
     868                 :            :                     first_good_char_pos = 0;
     869                 :            :                     last_good_char_pos = i;
     870                 :            :                     break;
     871                 :            :                 }
     872                 :            :             }
     873                 :            :             last_good_char_pos = i;
     874                 :            :         }
     875                 :        568 :         i += delta;
     876                 :            :     }
     877                 :            : 
     878         [ +  + ]:        164 :     if (!first_good_char_pos_set) {
     879                 :            :         // string is all whitespace, return ''
     880         [ +  + ]:         16 :         if (self_type == &mp_type_str) {
     881                 :            :             return MP_OBJ_NEW_QSTR(MP_QSTR_);
     882                 :            :         } else {
     883                 :          8 :             return mp_const_empty_bytes;
     884                 :            :         }
     885                 :            :     }
     886                 :            : 
     887         [ -  + ]:        148 :     assert(last_good_char_pos >= first_good_char_pos);
     888                 :            :     // +1 to accommodate the last character
     889                 :        148 :     size_t stripped_len = last_good_char_pos - first_good_char_pos + 1;
     890         [ +  + ]:        148 :     if (stripped_len == orig_str_len) {
     891                 :            :         // If nothing was stripped, don't bother to dup original string
     892                 :            :         // TODO: watch out for this case when we'll get to bytearray.strip()
     893         [ -  + ]:         48 :         assert(first_good_char_pos == 0);
     894                 :         48 :         return args[0];
     895                 :            :     }
     896                 :        100 :     return mp_obj_new_str_of_type(self_type, orig_str + first_good_char_pos, stripped_len);
     897                 :            : }
     898                 :            : 
     899                 :         80 : STATIC mp_obj_t str_strip(size_t n_args, const mp_obj_t *args) {
     900                 :         80 :     return str_uni_strip(STRIP, n_args, args);
     901                 :            : }
     902                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_strip_obj, 1, 2, str_strip);
     903                 :            : 
     904                 :         40 : STATIC mp_obj_t str_lstrip(size_t n_args, const mp_obj_t *args) {
     905                 :         40 :     return str_uni_strip(LSTRIP, n_args, args);
     906                 :            : }
     907                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_lstrip_obj, 1, 2, str_lstrip);
     908                 :            : 
     909                 :         52 : STATIC mp_obj_t str_rstrip(size_t n_args, const mp_obj_t *args) {
     910                 :         52 :     return str_uni_strip(RSTRIP, n_args, args);
     911                 :            : }
     912                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_rstrip_obj, 1, 2, str_rstrip);
     913                 :            : 
     914                 :            : #if MICROPY_PY_BUILTINS_STR_CENTER
     915                 :         64 : STATIC mp_obj_t str_center(mp_obj_t str_in, mp_obj_t width_in) {
     916         [ +  + ]:         64 :     GET_STR_DATA_LEN(str_in, str, str_len);
     917                 :         64 :     mp_uint_t width = mp_obj_get_int(width_in);
     918         [ +  + ]:         64 :     if (str_len >= width) {
     919                 :            :         return str_in;
     920                 :            :     }
     921                 :            : 
     922                 :         40 :     vstr_t vstr;
     923                 :         40 :     vstr_init_len(&vstr, width);
     924                 :         40 :     memset(vstr.buf, ' ', width);
     925                 :         40 :     int left = (width - str_len) / 2;
     926                 :         40 :     memcpy(vstr.buf + left, str, str_len);
     927                 :         40 :     return mp_obj_new_str_type_from_vstr(mp_obj_get_type(str_in), &vstr);
     928                 :            : }
     929                 :            : MP_DEFINE_CONST_FUN_OBJ_2(str_center_obj, str_center);
     930                 :            : #endif
     931                 :            : 
     932                 :            : // Takes an int arg, but only parses unsigned numbers, and only changes
     933                 :            : // *num if at least one digit was parsed.
     934                 :     160370 : STATIC const char *str_to_int(const char *str, const char *top, int *num) {
     935   [ +  +  +  +  :     160370 :     if (str < top && '0' <= *str && *str <= '9') {
                   +  + ]
     936                 :      94306 :         *num = 0;
     937                 :     124690 :         do {
     938                 :     124690 :             *num = *num * 10 + (*str - '0');
     939                 :     124690 :             str++;
     940                 :            :         }
     941   [ +  +  +  +  :     124690 :         while (str < top && '0' <= *str && *str <= '9');
                   +  + ]
     942                 :            :     }
     943                 :     160370 :     return str;
     944                 :            : }
     945                 :            : 
     946                 :      54436 : STATIC bool isalignment(char ch) {
     947   [ +  +  +  + ]:      54436 :     return ch && strchr("<>=^", ch) != NULL;
     948                 :            : }
     949                 :            : 
     950                 :      27552 : STATIC bool istype(char ch) {
     951   [ +  +  +  + ]:      27552 :     return ch && strchr("bcdeEfFgGnosxX%", ch) != NULL;
     952                 :            : }
     953                 :            : 
     954                 :     145674 : STATIC bool arg_looks_integer(mp_obj_t arg) {
     955   [ +  +  +  +  :     145674 :     return mp_obj_is_bool(arg) || mp_obj_is_int(arg);
             +  +  +  + ]
     956                 :            : }
     957                 :            : 
     958                 :      90848 : STATIC bool arg_looks_numeric(mp_obj_t arg) {
     959                 :      90848 :     return arg_looks_integer(arg)
     960                 :            :            #if MICROPY_PY_BUILTINS_FLOAT
     961   [ +  +  -  +  :      90848 :            || mp_obj_is_float(arg)
          -  +  -  +  -  
             +  +  +  +  
                      + ]
     962                 :            :            #endif
     963                 :            :     ;
     964                 :            : }
     965                 :            : 
     966                 :            : #if MICROPY_PY_BUILTINS_STR_OP_MODULO
     967                 :      22236 : STATIC mp_obj_t arg_as_int(mp_obj_t arg) {
     968                 :            :     #if MICROPY_PY_BUILTINS_FLOAT
     969   [ -  +  -  +  :      22236 :     if (mp_obj_is_float(arg)) {
          -  +  -  +  +  
                +  +  + ]
     970                 :         32 :         return mp_obj_new_int_from_float(mp_obj_float_get(arg));
     971                 :            :     }
     972                 :            :     #endif
     973                 :            :     return arg;
     974                 :            : }
     975                 :            : #endif
     976                 :            : 
     977                 :            : #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
     978                 :            : STATIC NORETURN void terse_str_format_value_error(void) {
     979                 :            :     mp_raise_ValueError(MP_ERROR_TEXT("bad format string"));
     980                 :            : }
     981                 :            : #else
     982                 :            : // define to nothing to improve coverage
     983                 :            : #define terse_str_format_value_error()
     984                 :            : #endif
     985                 :            : 
     986                 :      64414 : STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *arg_i, size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
     987                 :      64414 :     vstr_t vstr;
     988                 :      64414 :     mp_print_t print;
     989                 :      64414 :     vstr_init_print(&vstr, 16, &print);
     990                 :            : 
     991         [ +  + ]:     333390 :     for (; str < top; str++) {
     992         [ +  + ]:     204644 :         if (*str == '}') {
     993                 :         20 :             str++;
     994   [ +  +  +  - ]:         20 :             if (str < top && *str == '}') {
     995                 :         12 :                 vstr_add_byte(&vstr, '}');
     996                 :     165982 :                 continue;
     997                 :            :             }
     998                 :            :             #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
     999                 :            :             terse_str_format_value_error();
    1000                 :            :             #else
    1001                 :          8 :             mp_raise_ValueError(MP_ERROR_TEXT("single '}' encountered in format string"));
    1002                 :            :             #endif
    1003                 :            :         }
    1004         [ +  + ]:     204624 :         if (*str != '{') {
    1005                 :     149742 :             vstr_add_byte(&vstr, *str);
    1006                 :     149742 :             continue;
    1007                 :            :         }
    1008                 :            : 
    1009                 :      54882 :         str++;
    1010   [ +  -  +  + ]:      54882 :         if (str < top && *str == '{') {
    1011                 :         16 :             vstr_add_byte(&vstr, '{');
    1012                 :         16 :             continue;
    1013                 :            :         }
    1014                 :            : 
    1015                 :            :         // replacement_field ::=  "{" [field_name] ["!" conversion] [":" format_spec] "}"
    1016                 :            : 
    1017                 :      54866 :         const char *field_name = NULL;
    1018                 :      54866 :         const char *field_name_top = NULL;
    1019                 :      54866 :         char conversion = '\0';
    1020                 :      54866 :         const char *format_spec = NULL;
    1021                 :            : 
    1022   [ +  -  +  +  :      54866 :         if (str < top && *str != '}' && *str != '!' && *str != ':') {
             +  +  +  + ]
    1023                 :       1442 :             field_name = (const char *)str;
    1024   [ +  +  +  +  :       1442 :             while (str < top && *str != '}' && *str != '!' && *str != ':') {
             +  +  +  + ]
    1025                 :       1314 :                 ++str;
    1026                 :            :             }
    1027                 :            :             field_name_top = (const char *)str;
    1028                 :            :         }
    1029                 :            : 
    1030                 :            :         // conversion ::=  "r" | "s"
    1031                 :            : 
    1032   [ +  +  +  + ]:      54866 :         if (str < top && *str == '!') {
    1033                 :       2080 :             str++;
    1034   [ +  +  +  + ]:       2080 :             if (str < top && (*str == 'r' || *str == 's')) {
    1035                 :       2072 :                 conversion = *str++;
    1036                 :            :             } else {
    1037                 :            :                 #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1038                 :            :                 terse_str_format_value_error();
    1039                 :            :                 #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL
    1040                 :            :                 mp_raise_ValueError(MP_ERROR_TEXT("bad conversion specifier"));
    1041                 :            :                 #else
    1042         [ +  + ]:          8 :                 if (str >= top) {
    1043                 :          4 :                     mp_raise_ValueError(
    1044                 :          4 :                         MP_ERROR_TEXT("end of format while looking for conversion specifier"));
    1045                 :            :                 } else {
    1046                 :          4 :                     mp_raise_msg_varg(&mp_type_ValueError,
    1047                 :          4 :                         MP_ERROR_TEXT("unknown conversion specifier %c"), *str);
    1048                 :            :                 }
    1049                 :            :                 #endif
    1050                 :            :             }
    1051                 :            :         }
    1052                 :            : 
    1053   [ +  +  +  + ]:      54858 :         if (str < top && *str == ':') {
    1054                 :      27564 :             str++;
    1055                 :            :             // {:} is the same as {}, which is the same as {!s}
    1056                 :            :             // This makes a difference when passing in a True or False
    1057                 :            :             // '{}'.format(True) returns 'True'
    1058                 :            :             // '{:d}'.format(True) returns '1'
    1059                 :            :             // So we treat {:} as {} and this later gets treated to be {!s}
    1060         [ +  + ]:      27564 :             if (*str != '}') {
    1061                 :     102652 :                 format_spec = str;
    1062         [ +  - ]:     102652 :                 for (int nest = 1; str < top;) {
    1063         [ +  + ]:     102652 :                     if (*str == '{') {
    1064                 :         48 :                         ++nest;
    1065         [ +  + ]:     102604 :                     } else if (*str == '}') {
    1066         [ +  + ]:      27604 :                         if (--nest == 0) {
    1067                 :            :                             break;
    1068                 :            :                         }
    1069                 :            :                     }
    1070                 :      75096 :                     ++str;
    1071                 :            :                 }
    1072                 :            :             }
    1073                 :            :         }
    1074         [ +  + ]:      54858 :         if (str >= top) {
    1075                 :            :             #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1076                 :            :             terse_str_format_value_error();
    1077                 :            :             #else
    1078                 :          4 :             mp_raise_ValueError(MP_ERROR_TEXT("unmatched '{' in format"));
    1079                 :            :             #endif
    1080                 :            :         }
    1081         [ +  + ]:      54854 :         if (*str != '}') {
    1082                 :            :             #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1083                 :            :             terse_str_format_value_error();
    1084                 :            :             #else
    1085                 :          4 :             mp_raise_ValueError(MP_ERROR_TEXT("expected ':' after format specifier"));
    1086                 :            :             #endif
    1087                 :            :         }
    1088                 :            : 
    1089                 :      54850 :         mp_obj_t arg = mp_const_none;
    1090                 :            : 
    1091         [ +  + ]:      54850 :         if (field_name) {
    1092                 :        124 :             int index = 0;
    1093         [ +  + ]:        124 :             if (MP_LIKELY(unichar_isdigit(*field_name))) {
    1094         [ +  + ]:         68 :                 if (*arg_i > 0) {
    1095                 :            :                     #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1096                 :            :                     terse_str_format_value_error();
    1097                 :            :                     #else
    1098                 :          4 :                     mp_raise_ValueError(
    1099                 :          4 :                         MP_ERROR_TEXT("can't switch from automatic field numbering to manual field specification"));
    1100                 :            :                     #endif
    1101                 :            :                 }
    1102                 :         64 :                 field_name = str_to_int(field_name, field_name_top, &index);
    1103         [ +  + ]:         64 :                 if ((uint)index >= n_args - 1) {
    1104                 :          8 :                     mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("tuple index out of range"));
    1105                 :            :                 }
    1106                 :         56 :                 arg = args[index + 1];
    1107                 :         56 :                 *arg_i = -1;
    1108                 :            :             } else {
    1109                 :            :                 const char *lookup;
    1110   [ +  +  +  -  :       1284 :                 for (lookup = field_name; lookup < field_name_top && *lookup != '.' && *lookup != '['; lookup++) {;
                   +  + ]
    1111                 :            :                 }
    1112                 :         56 :                 mp_obj_t field_q = mp_obj_new_str_via_qstr(field_name, lookup - field_name); // should it be via qstr?
    1113                 :         56 :                 field_name = lookup;
    1114                 :         56 :                 mp_map_elem_t *key_elem = mp_map_lookup(kwargs, field_q, MP_MAP_LOOKUP);
    1115         [ +  + ]:         56 :                 if (key_elem == NULL) {
    1116                 :          4 :                     mp_raise_type_arg(&mp_type_KeyError, field_q);
    1117                 :            :                 }
    1118                 :         52 :                 arg = key_elem->value;
    1119                 :            :             }
    1120         [ +  + ]:        108 :             if (field_name < field_name_top) {
    1121                 :          2 :                 mp_raise_NotImplementedError(MP_ERROR_TEXT("attributes not supported yet"));
    1122                 :            :             }
    1123                 :            :         } else {
    1124         [ +  + ]:      54726 :             if (*arg_i < 0) {
    1125                 :            :                 #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1126                 :            :                 terse_str_format_value_error();
    1127                 :            :                 #else
    1128                 :          4 :                 mp_raise_ValueError(
    1129                 :          4 :                     MP_ERROR_TEXT("can't switch from manual field specification to automatic field numbering"));
    1130                 :            :                 #endif
    1131                 :            :             }
    1132         [ +  + ]:      54722 :             if ((uint)*arg_i >= n_args - 1) {
    1133                 :          4 :                 mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("tuple index out of range"));
    1134                 :            :             }
    1135                 :      54718 :             arg = args[(*arg_i) + 1];
    1136                 :      54718 :             (*arg_i)++;
    1137                 :            :         }
    1138         [ +  + ]:      54824 :         if (!format_spec && !conversion) {
    1139                 :            :             conversion = 's';
    1140                 :            :         }
    1141         [ +  + ]:      27564 :         if (conversion) {
    1142                 :      29328 :             mp_print_kind_t print_kind;
    1143         [ +  + ]:      29328 :             if (conversion == 's') {
    1144                 :            :                 print_kind = PRINT_STR;
    1145                 :            :             } else {
    1146         [ -  + ]:       1036 :                 assert(conversion == 'r');
    1147                 :            :                 print_kind = PRINT_REPR;
    1148                 :            :             }
    1149                 :      29328 :             vstr_t arg_vstr;
    1150                 :      29328 :             mp_print_t arg_print;
    1151                 :      29328 :             vstr_init_print(&arg_vstr, 16, &arg_print);
    1152                 :      29328 :             mp_obj_print_helper(&arg_print, arg, print_kind);
    1153                 :      29328 :             arg = mp_obj_new_str_type_from_vstr(&mp_type_str, &arg_vstr);
    1154                 :            :         }
    1155                 :            : 
    1156                 :      54824 :         char fill = '\0';
    1157                 :      54824 :         char align = '\0';
    1158                 :      54824 :         int width = -1;
    1159                 :      54824 :         int precision = -1;
    1160                 :      54824 :         char type = '\0';
    1161                 :      54824 :         int flags = 0;
    1162                 :            : 
    1163         [ +  + ]:      54824 :         if (format_spec) {
    1164                 :            :             // The format specifier (from http://docs.python.org/2/library/string.html#formatspec)
    1165                 :            :             //
    1166                 :            :             // [[fill]align][sign][#][0][width][,][.precision][type]
    1167                 :            :             // fill        ::=  <any character>
    1168                 :            :             // align       ::=  "<" | ">" | "=" | "^"
    1169                 :            :             // sign        ::=  "+" | "-" | " "
    1170                 :            :             // width       ::=  integer
    1171                 :            :             // precision   ::=  integer
    1172                 :            :             // type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
    1173                 :            : 
    1174                 :            :             // recursively call the formatter to format any nested specifiers
    1175                 :      27552 :             MP_STACK_CHECK();
    1176                 :      27552 :             vstr_t format_spec_vstr = mp_obj_str_format_helper(format_spec, str, arg_i, n_args, args, kwargs);
    1177                 :      27552 :             const char *s = vstr_null_terminated_str(&format_spec_vstr);
    1178                 :      27552 :             const char *stop = s + format_spec_vstr.len;
    1179         [ +  + ]:      27552 :             if (isalignment(*s)) {
    1180                 :        668 :                 align = *s++;
    1181   [ +  -  +  + ]:      26884 :             } else if (*s && isalignment(s[1])) {
    1182                 :       1908 :                 fill = *s++;
    1183                 :       1908 :                 align = *s++;
    1184                 :            :             }
    1185   [ +  +  +  + ]:      27552 :             if (*s == '+' || *s == '-' || *s == ' ') {
    1186         [ +  + ]:         32 :                 if (*s == '+') {
    1187                 :            :                     flags |= PF_FLAG_SHOW_SIGN;
    1188         [ +  + ]:         16 :                 } else if (*s == ' ') {
    1189                 :          8 :                     flags |= PF_FLAG_SPACE_SIGN;
    1190                 :            :                 }
    1191                 :         32 :                 s++;
    1192                 :            :             }
    1193         [ +  + ]:      27552 :             if (*s == '#') {
    1194                 :       5184 :                 flags |= PF_FLAG_SHOW_PREFIX;
    1195                 :       5184 :                 s++;
    1196                 :            :             }
    1197         [ +  + ]:      27552 :             if (*s == '0') {
    1198   [ +  +  +  + ]:      10748 :                 if (!align && arg_looks_numeric(arg)) {
    1199                 :      10732 :                     align = '=';
    1200                 :            :                 }
    1201         [ +  - ]:      10748 :                 if (!fill) {
    1202                 :      10748 :                     fill = '0';
    1203                 :            :                 }
    1204                 :            :             }
    1205                 :      27552 :             s = str_to_int(s, stop, &width);
    1206         [ +  + ]:      27552 :             if (*s == ',') {
    1207                 :          8 :                 flags |= PF_FLAG_SHOW_COMMA;
    1208                 :          8 :                 s++;
    1209                 :            :             }
    1210         [ +  + ]:      27552 :             if (*s == '.') {
    1211                 :       4448 :                 s++;
    1212                 :       4448 :                 s = str_to_int(s, stop, &precision);
    1213                 :            :             }
    1214         [ +  + ]:      27552 :             if (istype(*s)) {
    1215                 :      27488 :                 type = *s++;
    1216                 :            :             }
    1217         [ +  + ]:      27552 :             if (*s) {
    1218                 :            :                 #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1219                 :            :                 terse_str_format_value_error();
    1220                 :            :                 #else
    1221                 :          4 :                 mp_raise_ValueError(MP_ERROR_TEXT("invalid format specifier"));
    1222                 :            :                 #endif
    1223                 :            :             }
    1224                 :      27548 :             vstr_clear(&format_spec_vstr);
    1225                 :            :         }
    1226         [ +  + ]:      54820 :         if (!align) {
    1227         [ +  + ]:      41512 :             if (arg_looks_numeric(arg)) {
    1228                 :            :                 align = '>';
    1229                 :            :             } else {
    1230                 :      31732 :                 align = '<';
    1231                 :            :             }
    1232                 :            :         }
    1233         [ +  + ]:      54820 :         if (!fill) {
    1234                 :      42164 :             fill = ' ';
    1235                 :            :         }
    1236                 :            : 
    1237         [ +  + ]:      54820 :         if (flags & (PF_FLAG_SHOW_SIGN | PF_FLAG_SPACE_SIGN)) {
    1238         [ +  + ]:         24 :             if (type == 's') {
    1239                 :            :                 #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1240                 :            :                 terse_str_format_value_error();
    1241                 :            :                 #else
    1242                 :          4 :                 mp_raise_ValueError(MP_ERROR_TEXT("sign not allowed in string format specifier"));
    1243                 :            :                 #endif
    1244                 :            :             }
    1245         [ +  + ]:         20 :             if (type == 'c') {
    1246                 :            :                 #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1247                 :            :                 terse_str_format_value_error();
    1248                 :            :                 #else
    1249                 :          4 :                 mp_raise_ValueError(
    1250                 :          4 :                     MP_ERROR_TEXT("sign not allowed with integer format specifier 'c'"));
    1251                 :            :                 #endif
    1252                 :            :             }
    1253                 :            :         }
    1254                 :            : 
    1255   [ +  +  +  + ]:      54812 :         switch (align) {
    1256                 :      32612 :             case '<':
    1257                 :      32612 :                 flags |= PF_FLAG_LEFT_ADJUST;
    1258                 :      32612 :                 break;
    1259                 :      10740 :             case '=':
    1260                 :      10740 :                 flags |= PF_FLAG_PAD_AFTER_SIGN;
    1261                 :      10740 :                 break;
    1262                 :        828 :             case '^':
    1263                 :        828 :                 flags |= PF_FLAG_CENTER_ADJUST;
    1264                 :        828 :                 break;
    1265                 :            :         }
    1266                 :            : 
    1267         [ +  + ]:      54812 :         if (arg_looks_integer(arg)) {
    1268   [ +  +  +  +  :      18544 :             switch (type) {
                +  +  + ]
    1269                 :       5156 :                 case 'b':
    1270                 :       5156 :                     mp_print_mp_int(&print, arg, 2, 'a', flags, fill, width, 0);
    1271                 :       5156 :                     continue;
    1272                 :            : 
    1273                 :        392 :                 case 'c': {
    1274                 :        196 :                     char ch = mp_obj_get_int(arg);
    1275                 :        196 :                     mp_print_strn(&print, &ch, 1, flags, fill, width);
    1276                 :        196 :                     continue;
    1277                 :            :                 }
    1278                 :            : 
    1279                 :        112 :                 case '\0':  // No explicit format type implies 'd'
    1280                 :            :                 case 'n':   // I don't think we support locales in uPy so use 'd'
    1281                 :            :                 case 'd':
    1282                 :        112 :                     mp_print_mp_int(&print, arg, 10, 'a', flags, fill, width, 0);
    1283                 :        112 :                     continue;
    1284                 :            : 
    1285                 :         12 :                 case 'o':
    1286         [ +  + ]:         12 :                     if (flags & PF_FLAG_SHOW_PREFIX) {
    1287                 :          8 :                         flags |= PF_FLAG_SHOW_OCTAL_LETTER;
    1288                 :            :                     }
    1289                 :            : 
    1290                 :         12 :                     mp_print_mp_int(&print, arg, 8, 'a', flags, fill, width, 0);
    1291                 :         12 :                     continue;
    1292                 :            : 
    1293                 :      10736 :                 case 'X':
    1294                 :            :                 case 'x':
    1295                 :      10736 :                     mp_print_mp_int(&print, arg, 16, type - ('X' - 'A'), flags, fill, width, 0);
    1296                 :      10736 :                     continue;
    1297                 :            : 
    1298                 :            :                 case 'e':
    1299                 :            :                 case 'E':
    1300                 :            :                 case 'f':
    1301                 :            :                 case 'F':
    1302                 :            :                 case 'g':
    1303                 :            :                 case 'G':
    1304                 :            :                 case '%':
    1305                 :            :                     // The floating point formatters all work with anything that
    1306                 :            :                     // looks like an integer
    1307                 :            :                     break;
    1308                 :            : 
    1309                 :          4 :                 default:
    1310                 :            :                     #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1311                 :            :                     terse_str_format_value_error();
    1312                 :            :                     #else
    1313                 :          4 :                     mp_raise_msg_varg(&mp_type_ValueError,
    1314                 :          4 :                         MP_ERROR_TEXT("unknown format code '%c' for object of type '%s'"),
    1315                 :            :                         type, mp_obj_get_type_str(arg));
    1316                 :            :                     #endif
    1317                 :            :             }
    1318                 :            :         }
    1319                 :            : 
    1320                 :            :         // NOTE: no else here. We need the e, f, g etc formats for integer
    1321                 :            :         //       arguments (from above if) to take this if.
    1322         [ +  + ]:      38596 :         if (arg_looks_numeric(arg)) {
    1323         [ +  + ]:       4508 :             if (!type) {
    1324                 :            : 
    1325                 :            :                 // Even though the docs say that an unspecified type is the same
    1326                 :            :                 // as 'g', there is one subtle difference, when the exponent
    1327                 :            :                 // is one less than the precision.
    1328                 :            :                 //
    1329                 :            :                 // '{:10.1}'.format(0.0) ==> '0e+00'
    1330                 :            :                 // '{:10.1g}'.format(0.0) ==> '0'
    1331                 :            :                 //
    1332                 :            :                 // TODO: Figure out how to deal with this.
    1333                 :            :                 //
    1334                 :            :                 // A proper solution would involve adding a special flag
    1335                 :            :                 // or something to format_float, and create a format_double
    1336                 :            :                 // to deal with doubles. In order to fix this when using
    1337                 :            :                 // sprintf, we'd need to use the e format and tweak the
    1338                 :            :                 // returned result to strip trailing zeros like the g format
    1339                 :            :                 // does.
    1340                 :            :                 //
    1341                 :            :                 // {:10.3} and {:10.2e} with 1.23e2 both produce 1.23e+02
    1342                 :            :                 // but with 1.e2 you get 1e+02 and 1.00e+02
    1343                 :            :                 //
    1344                 :            :                 // Stripping the trailing 0's (like g) does would make the
    1345                 :            :                 // e format give us the right format.
    1346                 :            :                 //
    1347                 :            :                 // CPython sources say:
    1348                 :            :                 //   Omitted type specifier.  Behaves in the same way as repr(x)
    1349                 :            :                 //   and str(x) if no precision is given, else like 'g', but with
    1350                 :            :                 //   at least one digit after the decimal point. */
    1351                 :            : 
    1352                 :            :                 type = 'g';
    1353                 :            :             }
    1354         [ +  + ]:       4500 :             if (type == 'n') {
    1355                 :            :                 type = 'g';
    1356                 :            :             }
    1357                 :            : 
    1358      [ +  +  + ]:       4500 :             switch (type) {
    1359                 :            :                 #if MICROPY_PY_BUILTINS_FLOAT
    1360                 :       4476 :                 case 'e':
    1361                 :            :                 case 'E':
    1362                 :            :                 case 'f':
    1363                 :            :                 case 'F':
    1364                 :            :                 case 'g':
    1365                 :            :                 case 'G':
    1366                 :       4476 :                     mp_print_float(&print, mp_obj_get_float(arg), type, flags, fill, width, precision);
    1367                 :       4476 :                     break;
    1368                 :            : 
    1369                 :         24 :                 case '%':
    1370                 :         24 :                     flags |= PF_FLAG_ADD_PERCENT;
    1371                 :            :                     #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
    1372                 :            :                     #define F100 100.0F
    1373                 :            :                     #else
    1374                 :            :                     #define F100 100.0
    1375                 :            :                     #endif
    1376                 :         24 :                     mp_print_float(&print, mp_obj_get_float(arg) * F100, 'f', flags, fill, width, precision);
    1377                 :            : #undef F100
    1378                 :         24 :                     break;
    1379                 :            :                 #endif
    1380                 :            : 
    1381                 :          8 :                 default:
    1382                 :            :                     #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1383                 :            :                     terse_str_format_value_error();
    1384                 :            :                     #else
    1385                 :          8 :                     mp_raise_msg_varg(&mp_type_ValueError,
    1386                 :          8 :                         MP_ERROR_TEXT("unknown format code '%c' for object of type '%s'"),
    1387                 :            :                         type, mp_obj_get_type_str(arg));
    1388                 :            :                     #endif
    1389                 :            :             }
    1390                 :            :         } else {
    1391                 :            :             // arg doesn't look like a number
    1392                 :            : 
    1393         [ +  + ]:      34088 :             if (align == '=') {
    1394                 :            :                 #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1395                 :            :                 terse_str_format_value_error();
    1396                 :            :                 #else
    1397                 :          4 :                 mp_raise_ValueError(
    1398                 :          4 :                     MP_ERROR_TEXT("'=' alignment not allowed in string format specifier"));
    1399                 :            :                 #endif
    1400                 :            :             }
    1401                 :            : 
    1402         [ +  + ]:      34084 :             switch (type) {
    1403                 :      34080 :                 case '\0': // no explicit format type implies 's'
    1404                 :            :                 case 's': {
    1405                 :      34080 :                     size_t slen;
    1406                 :      34080 :                     const char *s = mp_obj_str_get_data(arg, &slen);
    1407         [ +  + ]:      34080 :                     if (precision < 0) {
    1408                 :      34076 :                         precision = slen;
    1409                 :            :                     }
    1410         [ +  + ]:      34080 :                     if (slen > (size_t)precision) {
    1411                 :          4 :                         slen = precision;
    1412                 :            :                     }
    1413                 :      34080 :                     mp_print_strn(&print, s, slen, flags, fill, width);
    1414                 :      34080 :                     break;
    1415                 :            :                 }
    1416                 :            : 
    1417                 :          4 :                 default:
    1418                 :            :                     #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1419                 :            :                     terse_str_format_value_error();
    1420                 :            :                     #else
    1421                 :          4 :                     mp_raise_msg_varg(&mp_type_ValueError,
    1422                 :          4 :                         MP_ERROR_TEXT("unknown format code '%c' for object of type '%s'"),
    1423                 :            :                         type, mp_obj_get_type_str(arg));
    1424                 :            :                     #endif
    1425                 :            :             }
    1426                 :            :         }
    1427                 :            :     }
    1428                 :            : 
    1429                 :      64332 :     return vstr;
    1430                 :            : }
    1431                 :            : 
    1432                 :      36862 : mp_obj_t mp_obj_str_format(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
    1433                 :      36862 :     check_is_str_or_bytes(args[0]);
    1434                 :            : 
    1435         [ +  + ]:      36862 :     GET_STR_DATA_LEN(args[0], str, len);
    1436                 :      36862 :     int arg_i = 0;
    1437                 :      36862 :     vstr_t vstr = mp_obj_str_format_helper((const char *)str, (const char *)str + len, &arg_i, n_args, args, kwargs);
    1438                 :      36780 :     return mp_obj_new_str_type_from_vstr(mp_obj_get_type(args[0]), &vstr);
    1439                 :            : }
    1440                 :            : MP_DEFINE_CONST_FUN_OBJ_KW(str_format_obj, 1, mp_obj_str_format);
    1441                 :            : 
    1442                 :            : #if MICROPY_PY_BUILTINS_STR_OP_MODULO
    1443                 :      85290 : STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_t *args, mp_obj_t dict) {
    1444                 :      85290 :     check_is_str_or_bytes(pattern);
    1445                 :            : 
    1446         [ +  + ]:      85290 :     GET_STR_DATA_LEN(pattern, str, len);
    1447                 :            :     #if MICROPY_ERROR_REPORTING > MICROPY_ERROR_REPORTING_TERSE
    1448                 :      85290 :     const byte *start_str = str;
    1449                 :            :     #endif
    1450   [ +  +  +  + ]:      85290 :     bool is_bytes = mp_obj_is_type(pattern, &mp_type_bytes);
    1451                 :      85290 :     size_t arg_i = 0;
    1452                 :      85290 :     vstr_t vstr;
    1453                 :      85290 :     mp_print_t print;
    1454                 :      85290 :     vstr_init_print(&vstr, 16, &print);
    1455                 :            : 
    1456         [ +  + ]:     215248 :     for (const byte *top = str + len; str < top; str++) {
    1457                 :     130023 :         mp_obj_t arg = MP_OBJ_NULL;
    1458         [ +  + ]:     130023 :         if (*str != '%') {
    1459                 :      34285 :             vstr_add_byte(&vstr, *str);
    1460                 :      34324 :             continue;
    1461                 :            :         }
    1462         [ +  + ]:      95738 :         if (++str >= top) {
    1463                 :          4 :             goto incomplete_format;
    1464                 :            :         }
    1465         [ +  + ]:      95734 :         if (*str == '%') {
    1466                 :         40 :             vstr_add_byte(&vstr, '%');
    1467                 :         40 :             continue;
    1468                 :            :         }
    1469                 :            : 
    1470                 :            :         // Dictionary value lookup
    1471         [ +  + ]:      95694 :         if (*str == '(') {
    1472         [ +  + ]:         42 :             if (dict == MP_OBJ_NULL) {
    1473                 :          8 :                 mp_raise_TypeError(MP_ERROR_TEXT("format needs a dict"));
    1474                 :            :             }
    1475                 :         34 :             arg_i = 1; // we used up the single dict argument
    1476                 :         34 :             const byte *key = ++str;
    1477         [ +  + ]:       2658 :             while (*str != ')') {
    1478         [ +  + ]:       2628 :                 if (str >= top) {
    1479                 :            :                     #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1480                 :            :                     terse_str_format_value_error();
    1481                 :            :                     #else
    1482                 :          4 :                     mp_raise_ValueError(MP_ERROR_TEXT("incomplete format key"));
    1483                 :            :                     #endif
    1484                 :            :                 }
    1485                 :       2624 :                 ++str;
    1486                 :            :             }
    1487                 :         30 :             mp_obj_t k_obj = mp_obj_new_str_via_qstr((const char *)key, str - key);
    1488                 :         24 :             arg = mp_obj_dict_get(dict, k_obj);
    1489                 :         20 :             str++;
    1490                 :            :         }
    1491                 :            : 
    1492                 :      95672 :         int flags = 0;
    1493                 :      95672 :         char fill = ' ';
    1494                 :      95672 :         int alt = 0;
    1495         [ +  - ]:     135976 :         while (str < top) {
    1496         [ +  + ]:     135976 :             if (*str == '-') {
    1497                 :         28 :                 flags |= PF_FLAG_LEFT_ADJUST;
    1498         [ +  + ]:     135948 :             } else if (*str == '+') {
    1499                 :        136 :                 flags |= PF_FLAG_SHOW_SIGN;
    1500         [ +  + ]:     135812 :             } else if (*str == ' ') {
    1501                 :         56 :                 flags |= PF_FLAG_SPACE_SIGN;
    1502         [ +  + ]:     135756 :             } else if (*str == '#') {
    1503                 :            :                 alt = PF_FLAG_SHOW_PREFIX;
    1504         [ +  + ]:     135516 :             } else if (*str == '0') {
    1505                 :      39844 :                 flags |= PF_FLAG_PAD_AFTER_SIGN;
    1506                 :      39844 :                 fill = '0';
    1507                 :            :             } else {
    1508                 :            :                 break;
    1509                 :            :             }
    1510                 :      40304 :             str++;
    1511                 :            :         }
    1512                 :            :         // parse width, if it exists
    1513                 :      95672 :         int width = 0;
    1514         [ +  - ]:      95672 :         if (str < top) {
    1515         [ +  + ]:      95672 :             if (*str == '*') {
    1516         [ +  + ]:         28 :                 if (arg_i >= n_args) {
    1517                 :          4 :                     goto not_enough_args;
    1518                 :            :                 }
    1519                 :         24 :                 width = mp_obj_get_int(args[arg_i++]);
    1520                 :         24 :                 str++;
    1521                 :            :             } else {
    1522                 :      95644 :                 str = (const byte *)str_to_int((const char *)str, (const char *)top, &width);
    1523                 :            :             }
    1524                 :            :         }
    1525                 :      95668 :         int prec = -1;
    1526   [ +  +  +  + ]:      95668 :         if (str < top && *str == '.') {
    1527         [ +  - ]:      32682 :             if (++str < top) {
    1528         [ +  + ]:      32682 :                 if (*str == '*') {
    1529         [ +  + ]:         20 :                     if (arg_i >= n_args) {
    1530                 :          4 :                         goto not_enough_args;
    1531                 :            :                     }
    1532                 :         16 :                     prec = mp_obj_get_int(args[arg_i++]);
    1533                 :         16 :                     str++;
    1534                 :            :                 } else {
    1535                 :      32662 :                     prec = 0;
    1536                 :      32662 :                     str = (const byte *)str_to_int((const char *)str, (const char *)top, &prec);
    1537                 :            :                 }
    1538                 :            :             }
    1539                 :            :         }
    1540                 :            : 
    1541         [ +  + ]:      95664 :         if (str >= top) {
    1542                 :          4 :         incomplete_format:
    1543                 :            :             #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1544                 :            :             terse_str_format_value_error();
    1545                 :            :             #else
    1546                 :          8 :             mp_raise_ValueError(MP_ERROR_TEXT("incomplete format"));
    1547                 :            :             #endif
    1548                 :            :         }
    1549                 :            : 
    1550                 :            :         // Tuple value lookup
    1551         [ +  + ]:      95660 :         if (arg == MP_OBJ_NULL) {
    1552         [ +  + ]:      95644 :             if (arg_i >= n_args) {
    1553                 :         16 :             not_enough_args:
    1554                 :         24 :                 mp_raise_TypeError(MP_ERROR_TEXT("format string needs more arguments"));
    1555                 :            :             }
    1556                 :      95628 :             arg = args[arg_i++];
    1557                 :            :         }
    1558   [ +  +  +  +  :      95644 :         switch (*str) {
                +  +  + ]
    1559                 :         22 :             case 'c':
    1560   [ +  +  +  +  :         26 :                 if (mp_obj_is_str(arg)) {
                   -  + ]
    1561                 :          8 :                     size_t slen;
    1562                 :          8 :                     const char *s = mp_obj_str_get_data(arg, &slen);
    1563         [ +  + ]:          8 :                     if (slen != 1) {
    1564                 :          4 :                         mp_raise_TypeError(MP_ERROR_TEXT("%c needs int or char"));
    1565                 :            :                     }
    1566                 :          4 :                     mp_print_strn(&print, s, 1, flags, ' ', width);
    1567         [ +  + ]:         14 :                 } else if (arg_looks_integer(arg)) {
    1568                 :         12 :                     char ch = mp_obj_get_int(arg);
    1569                 :         12 :                     mp_print_strn(&print, &ch, 1, flags, ' ', width);
    1570                 :            :                 } else {
    1571                 :          2 :                     mp_raise_TypeError(MP_ERROR_TEXT("integer needed"));
    1572                 :            :                 }
    1573                 :            :                 break;
    1574                 :            : 
    1575                 :      22236 :             case 'd':
    1576                 :            :             case 'i':
    1577                 :            :             case 'u':
    1578                 :      22236 :                 mp_print_mp_int(&print, arg_as_int(arg), 10, 'a', flags, fill, width, prec);
    1579                 :      22236 :                 break;
    1580                 :            : 
    1581                 :            :             #if MICROPY_PY_BUILTINS_FLOAT
    1582                 :      32674 :             case 'e':
    1583                 :            :             case 'E':
    1584                 :            :             case 'f':
    1585                 :            :             case 'F':
    1586                 :            :             case 'g':
    1587                 :            :             case 'G':
    1588                 :      32674 :                 mp_print_float(&print, mp_obj_get_float(arg), *str, flags, fill, width, prec);
    1589                 :      32674 :                 break;
    1590                 :            :             #endif
    1591                 :            : 
    1592                 :         40 :             case 'o':
    1593         [ +  + ]:         40 :                 if (alt) {
    1594                 :         36 :                     flags |= (PF_FLAG_SHOW_PREFIX | PF_FLAG_SHOW_OCTAL_LETTER);
    1595                 :            :                 }
    1596                 :         40 :                 mp_print_mp_int(&print, arg, 8, 'a', flags, fill, width, prec);
    1597                 :         40 :                 break;
    1598                 :            : 
    1599                 :        650 :             case 'r':
    1600                 :            :             case 's': {
    1601                 :        650 :                 vstr_t arg_vstr;
    1602                 :        650 :                 mp_print_t arg_print;
    1603                 :        650 :                 vstr_init_print(&arg_vstr, 16, &arg_print);
    1604                 :        650 :                 mp_print_kind_t print_kind = (*str == 'r' ? PRINT_REPR : PRINT_STR);
    1605   [ +  +  +  -  :        650 :                 if (print_kind == PRINT_STR && is_bytes && mp_obj_is_type(arg, &mp_type_bytes)) {
                   +  - ]
    1606                 :            :                     // If we have something like b"%s" % b"1", bytes arg should be
    1607                 :            :                     // printed undecorated.
    1608                 :          4 :                     print_kind = PRINT_RAW;
    1609                 :            :                 }
    1610                 :        650 :                 mp_obj_print_helper(&arg_print, arg, print_kind);
    1611                 :        650 :                 uint vlen = arg_vstr.len;
    1612         [ +  + ]:        650 :                 if (prec < 0) {
    1613                 :        646 :                     prec = vlen;
    1614                 :            :                 }
    1615         [ +  + ]:        650 :                 if (vlen > (uint)prec) {
    1616                 :          4 :                     vlen = prec;
    1617                 :            :                 }
    1618                 :        650 :                 mp_print_strn(&print, arg_vstr.buf, vlen, flags, ' ', width);
    1619                 :        650 :                 vstr_clear(&arg_vstr);
    1620                 :        650 :                 break;
    1621                 :            :             }
    1622                 :            : 
    1623                 :      40018 :             case 'X':
    1624                 :            :             case 'x':
    1625                 :      40018 :                 mp_print_mp_int(&print, arg, 16, *str - ('X' - 'A'), flags | alt, fill, width, prec);
    1626                 :      40018 :                 break;
    1627                 :            : 
    1628                 :          4 :             default:
    1629                 :            :                 #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    1630                 :            :                 terse_str_format_value_error();
    1631                 :            :                 #else
    1632                 :          4 :                 mp_raise_msg_varg(&mp_type_ValueError,
    1633                 :          4 :                     MP_ERROR_TEXT("unsupported format character '%c' (0x%x) at index %d"),
    1634                 :            :                     *str, *str, str - start_str);
    1635                 :            :                 #endif
    1636                 :            :         }
    1637                 :            :     }
    1638                 :            : 
    1639         [ +  + ]:      85225 :     if (arg_i != n_args) {
    1640                 :          4 :         mp_raise_TypeError(MP_ERROR_TEXT("format string didn't convert all arguments"));
    1641                 :            :     }
    1642                 :            : 
    1643         [ +  + ]:     170419 :     return mp_obj_new_str_type_from_vstr(is_bytes ? &mp_type_bytes : &mp_type_str, &vstr);
    1644                 :            : }
    1645                 :            : #endif
    1646                 :            : 
    1647                 :            : // The implementation is optimized, returning the original string if there's
    1648                 :            : // nothing to replace.
    1649                 :        116 : STATIC mp_obj_t str_replace(size_t n_args, const mp_obj_t *args) {
    1650                 :        116 :     check_is_str_or_bytes(args[0]);
    1651                 :            : 
    1652                 :        116 :     mp_int_t max_rep = -1;
    1653         [ +  + ]:        116 :     if (n_args == 4) {
    1654                 :         24 :         max_rep = mp_obj_get_int(args[3]);
    1655         [ +  + ]:         24 :         if (max_rep == 0) {
    1656                 :          8 :             return args[0];
    1657         [ +  + ]:         16 :         } else if (max_rep < 0) {
    1658                 :          8 :             max_rep = -1;
    1659                 :            :         }
    1660                 :            :     }
    1661                 :            : 
    1662                 :            :     // if max_rep is still -1 by this point we will need to do all possible replacements
    1663                 :            : 
    1664                 :            :     // check argument types
    1665                 :            : 
    1666                 :        108 :     const mp_obj_type_t *self_type = mp_obj_get_type(args[0]);
    1667                 :            : 
    1668                 :        108 :     str_check_arg_type(self_type, args[1]);
    1669                 :        104 :     str_check_arg_type(self_type, args[2]);
    1670                 :            : 
    1671                 :            :     // extract string data
    1672                 :            : 
    1673         [ +  + ]:        100 :     GET_STR_DATA_LEN(args[0], str, str_len);
    1674         [ +  + ]:        100 :     GET_STR_DATA_LEN(args[1], old, old_len);
    1675         [ +  + ]:        100 :     GET_STR_DATA_LEN(args[2], new, new_len);
    1676                 :            : 
    1677                 :            :     // old won't exist in str if it's longer, so nothing to replace
    1678         [ +  + ]:        100 :     if (old_len > str_len) {
    1679                 :         16 :         return args[0];
    1680                 :            :     }
    1681                 :            : 
    1682                 :            :     // data for the replaced string
    1683                 :            :     byte *data = NULL;
    1684                 :        160 :     vstr_t vstr;
    1685                 :            : 
    1686                 :            :     // do 2 passes over the string:
    1687                 :            :     //   first pass computes the required length of the replaced string
    1688                 :            :     //   second pass does the replacements
    1689                 :        160 :     for (;;) {
    1690                 :        160 :         size_t replaced_str_index = 0;
    1691                 :        160 :         size_t num_replacements_done = 0;
    1692                 :        160 :         const byte *old_occurrence;
    1693                 :        160 :         const byte *offset_ptr = str;
    1694                 :        160 :         size_t str_len_remain = str_len;
    1695         [ +  + ]:        160 :         if (old_len == 0) {
    1696                 :            :             // if old_str is empty, copy new_str to start of replaced string
    1697                 :            :             // copy the replacement string
    1698         [ +  + ]:         64 :             if (data != NULL) {
    1699                 :         32 :                 memcpy(data, new, new_len);
    1700                 :            :             }
    1701                 :         64 :             replaced_str_index += new_len;
    1702                 :         64 :             num_replacements_done++;
    1703                 :            :         }
    1704   [ +  +  +  + ]:        432 :         while (num_replacements_done != (size_t)max_rep && str_len_remain > 0 && (old_occurrence = find_subbytes(offset_ptr, str_len_remain, old, old_len, 1)) != NULL) {
    1705         [ +  + ]:        272 :             if (old_len == 0) {
    1706                 :         80 :                 old_occurrence += 1;
    1707                 :            :             }
    1708                 :            :             // copy from just after end of last occurrence of to-be-replaced string to right before start of next occurrence
    1709         [ +  + ]:        272 :             if (data != NULL) {
    1710                 :        136 :                 memcpy(data + replaced_str_index, offset_ptr, old_occurrence - offset_ptr);
    1711                 :            :             }
    1712                 :        272 :             replaced_str_index += old_occurrence - offset_ptr;
    1713                 :            :             // copy the replacement string
    1714         [ +  + ]:        272 :             if (data != NULL) {
    1715                 :        136 :                 memcpy(data + replaced_str_index, new, new_len);
    1716                 :            :             }
    1717                 :        272 :             replaced_str_index += new_len;
    1718                 :        272 :             offset_ptr = old_occurrence + old_len;
    1719                 :        272 :             str_len_remain = str + str_len - offset_ptr;
    1720                 :        272 :             num_replacements_done++;
    1721                 :            :         }
    1722                 :            : 
    1723                 :            :         // copy from just after end of last occurrence of to-be-replaced string to end of old string
    1724         [ +  + ]:        160 :         if (data != NULL) {
    1725                 :         76 :             memcpy(data + replaced_str_index, offset_ptr, str_len_remain);
    1726                 :            :         }
    1727                 :        160 :         replaced_str_index += str_len_remain;
    1728                 :            : 
    1729                 :        160 :         if (data == NULL) {
    1730                 :            :             // first pass
    1731         [ +  + ]:         84 :             if (num_replacements_done == 0) {
    1732                 :            :                 // no substr found, return original string
    1733                 :          8 :                 return args[0];
    1734                 :            :             } else {
    1735                 :            :                 // substr found, allocate new string
    1736                 :         76 :                 vstr_init_len(&vstr, replaced_str_index);
    1737                 :         76 :                 data = (byte *)vstr.buf;
    1738         [ +  - ]:         76 :                 assert(data != NULL);
    1739                 :            :             }
    1740                 :            :         } else {
    1741                 :            :             // second pass, we are done
    1742                 :            :             break;
    1743                 :            :         }
    1744                 :            :     }
    1745                 :            : 
    1746                 :         76 :     return mp_obj_new_str_type_from_vstr(self_type, &vstr);
    1747                 :            : }
    1748                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_replace_obj, 3, 4, str_replace);
    1749                 :            : 
    1750                 :            : #if MICROPY_PY_BUILTINS_STR_COUNT
    1751                 :        345 : STATIC mp_obj_t str_count(size_t n_args, const mp_obj_t *args) {
    1752                 :        345 :     const mp_obj_type_t *self_type = mp_obj_get_type(args[0]);
    1753                 :        345 :     check_is_str_or_bytes(args[0]);
    1754                 :            : 
    1755                 :            :     // check argument type
    1756                 :        345 :     str_check_arg_type(self_type, args[1]);
    1757                 :            : 
    1758         [ +  + ]:        341 :     GET_STR_DATA_LEN(args[0], haystack, haystack_len);
    1759         [ +  + ]:        341 :     GET_STR_DATA_LEN(args[1], needle, needle_len);
    1760                 :            : 
    1761                 :        341 :     const byte *start = haystack;
    1762                 :        341 :     const byte *end = haystack + haystack_len;
    1763   [ +  +  +  - ]:        341 :     if (n_args >= 3 && args[2] != mp_const_none) {
    1764                 :        152 :         start = str_index_to_ptr(self_type, haystack, haystack_len, args[2], true);
    1765                 :            :     }
    1766   [ +  +  +  - ]:        152 :     if (n_args >= 4 && args[3] != mp_const_none) {
    1767                 :         56 :         end = str_index_to_ptr(self_type, haystack, haystack_len, args[3], true);
    1768                 :            :     }
    1769                 :            : 
    1770                 :            :     // if needle_len is zero then we count each gap between characters as an occurrence
    1771         [ +  + ]:        341 :     if (needle_len == 0) {
    1772                 :         64 :         return MP_OBJ_NEW_SMALL_INT(utf8_charlen(start, end - start) + 1);
    1773                 :            :     }
    1774                 :            : 
    1775                 :            :     bool is_str = self_type == &mp_type_str;
    1776                 :            : 
    1777                 :            :     // count the occurrences
    1778                 :            :     mp_int_t num_occurrences = 0;
    1779         [ +  + ]:       1134 :     for (const byte *haystack_ptr = start; haystack_ptr + needle_len <= end;) {
    1780         [ +  + ]:        857 :         if (memcmp(haystack_ptr, needle, needle_len) == 0) {
    1781                 :        505 :             num_occurrences++;
    1782                 :        505 :             haystack_ptr += needle_len;
    1783                 :            :         } else {
    1784         [ +  + ]:        352 :             haystack_ptr = is_str ? utf8_next_char(haystack_ptr) : haystack_ptr + 1;
    1785                 :            :         }
    1786                 :            :     }
    1787                 :            : 
    1788                 :        277 :     return MP_OBJ_NEW_SMALL_INT(num_occurrences);
    1789                 :            : }
    1790                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_count_obj, 2, 4, str_count);
    1791                 :            : #endif
    1792                 :            : 
    1793                 :            : #if MICROPY_PY_BUILTINS_STR_PARTITION
    1794                 :        224 : STATIC mp_obj_t str_partitioner(mp_obj_t self_in, mp_obj_t arg, int direction) {
    1795                 :        224 :     check_is_str_or_bytes(self_in);
    1796                 :        224 :     const mp_obj_type_t *self_type = mp_obj_get_type(self_in);
    1797                 :        224 :     str_check_arg_type(self_type, arg);
    1798                 :            : 
    1799         [ +  + ]:        204 :     GET_STR_DATA_LEN(self_in, str, str_len);
    1800         [ +  + ]:        204 :     GET_STR_DATA_LEN(arg, sep, sep_len);
    1801                 :            : 
    1802         [ +  + ]:        204 :     if (sep_len == 0) {
    1803                 :         12 :         mp_raise_ValueError(MP_ERROR_TEXT("empty separator"));
    1804                 :            :     }
    1805                 :            : 
    1806                 :        192 :     mp_obj_t result[3];
    1807         [ +  + ]:        192 :     if (self_type == &mp_type_str) {
    1808                 :        120 :         result[0] = MP_OBJ_NEW_QSTR(MP_QSTR_);
    1809                 :        120 :         result[1] = MP_OBJ_NEW_QSTR(MP_QSTR_);
    1810                 :        120 :         result[2] = MP_OBJ_NEW_QSTR(MP_QSTR_);
    1811                 :            :     } else {
    1812                 :         72 :         result[0] = mp_const_empty_bytes;
    1813                 :         72 :         result[1] = mp_const_empty_bytes;
    1814                 :         72 :         result[2] = mp_const_empty_bytes;
    1815                 :            :     }
    1816                 :            : 
    1817         [ +  + ]:        192 :     if (direction > 0) {
    1818                 :        128 :         result[0] = self_in;
    1819                 :            :     } else {
    1820                 :         64 :         result[2] = self_in;
    1821                 :            :     }
    1822                 :            : 
    1823                 :            :     #if MICROPY_PY_BUILTINS_BYTEARRAY
    1824         [ +  + ]:        192 :     if (mp_obj_get_type(arg) != self_type) {
    1825                 :          8 :         arg = mp_obj_new_str_of_type(self_type, sep, sep_len);
    1826                 :            :     }
    1827                 :            :     #endif
    1828                 :            : 
    1829                 :        192 :     const byte *position_ptr = find_subbytes(str, str_len, sep, sep_len, direction);
    1830         [ +  + ]:        192 :     if (position_ptr != NULL) {
    1831                 :        144 :         size_t position = position_ptr - str;
    1832                 :        144 :         result[0] = mp_obj_new_str_of_type(self_type, str, position);
    1833                 :        144 :         result[1] = arg;
    1834                 :        144 :         result[2] = mp_obj_new_str_of_type(self_type, str + position + sep_len, str_len - position - sep_len);
    1835                 :            :     }
    1836                 :            : 
    1837                 :        192 :     return mp_obj_new_tuple(3, result);
    1838                 :            : }
    1839                 :            : 
    1840                 :        152 : STATIC mp_obj_t str_partition(mp_obj_t self_in, mp_obj_t arg) {
    1841                 :        152 :     return str_partitioner(self_in, arg, 1);
    1842                 :            : }
    1843                 :            : MP_DEFINE_CONST_FUN_OBJ_2(str_partition_obj, str_partition);
    1844                 :            : 
    1845                 :         72 : STATIC mp_obj_t str_rpartition(mp_obj_t self_in, mp_obj_t arg) {
    1846                 :         72 :     return str_partitioner(self_in, arg, -1);
    1847                 :            : }
    1848                 :            : MP_DEFINE_CONST_FUN_OBJ_2(str_rpartition_obj, str_rpartition);
    1849                 :            : #endif
    1850                 :            : 
    1851                 :            : // Supposedly not too critical operations, so optimize for code size
    1852                 :         46 : STATIC mp_obj_t str_caseconv(unichar (*op)(unichar), mp_obj_t self_in) {
    1853         [ +  + ]:         46 :     GET_STR_DATA_LEN(self_in, self_data, self_len);
    1854                 :         46 :     vstr_t vstr;
    1855                 :         46 :     vstr_init_len(&vstr, self_len);
    1856                 :         46 :     byte *data = (byte *)vstr.buf;
    1857         [ +  + ]:        280 :     for (size_t i = 0; i < self_len; i++) {
    1858                 :        234 :         *data++ = op(*self_data++);
    1859                 :            :     }
    1860                 :         46 :     return mp_obj_new_str_type_from_vstr(mp_obj_get_type(self_in), &vstr);
    1861                 :            : }
    1862                 :            : 
    1863                 :         14 : STATIC mp_obj_t str_lower(mp_obj_t self_in) {
    1864                 :         14 :     return str_caseconv(unichar_tolower, self_in);
    1865                 :            : }
    1866                 :            : MP_DEFINE_CONST_FUN_OBJ_1(str_lower_obj, str_lower);
    1867                 :            : 
    1868                 :         32 : STATIC mp_obj_t str_upper(mp_obj_t self_in) {
    1869                 :         32 :     return str_caseconv(unichar_toupper, self_in);
    1870                 :            : }
    1871                 :            : MP_DEFINE_CONST_FUN_OBJ_1(str_upper_obj, str_upper);
    1872                 :            : 
    1873                 :        102 : STATIC mp_obj_t str_uni_istype(bool (*f)(unichar), mp_obj_t self_in) {
    1874         [ +  + ]:        102 :     GET_STR_DATA_LEN(self_in, self_data, self_len);
    1875                 :            : 
    1876         [ +  + ]:        102 :     if (self_len == 0) {
    1877                 :            :         return mp_const_false; // default to False for empty str
    1878                 :            :     }
    1879                 :            : 
    1880   [ +  +  +  + ]:         82 :     if (f != unichar_isupper && f != unichar_islower) {
    1881         [ +  + ]:        528 :         for (size_t i = 0; i < self_len; i++) {
    1882         [ +  + ]:        506 :             if (!f(*self_data++)) {
    1883                 :            :                 return mp_const_false;
    1884                 :            :             }
    1885                 :            :         }
    1886                 :            :     } else {
    1887                 :            :         bool contains_alpha = false;
    1888                 :            : 
    1889         [ +  + ]:        388 :         for (size_t i = 0; i < self_len; i++) { // only check alphanumeric characters
    1890         [ +  + ]:        364 :             if (unichar_isalpha(*self_data++)) {
    1891                 :        240 :                 contains_alpha = true;
    1892         [ +  + ]:        240 :                 if (!f(*(self_data - 1))) { // -1 because we already incremented above
    1893                 :            :                     return mp_const_false;
    1894                 :            :                 }
    1895                 :            :             }
    1896                 :            :         }
    1897                 :            : 
    1898         [ +  + ]:         24 :         if (!contains_alpha) {
    1899                 :          4 :             return mp_const_false;
    1900                 :            :         }
    1901                 :            :     }
    1902                 :            : 
    1903                 :            :     return mp_const_true;
    1904                 :            : }
    1905                 :            : 
    1906                 :         20 : STATIC mp_obj_t str_isspace(mp_obj_t self_in) {
    1907                 :         20 :     return str_uni_istype(unichar_isspace, self_in);
    1908                 :            : }
    1909                 :            : MP_DEFINE_CONST_FUN_OBJ_1(str_isspace_obj, str_isspace);
    1910                 :            : 
    1911                 :         20 : STATIC mp_obj_t str_isalpha(mp_obj_t self_in) {
    1912                 :         20 :     return str_uni_istype(unichar_isalpha, self_in);
    1913                 :            : }
    1914                 :            : MP_DEFINE_CONST_FUN_OBJ_1(str_isalpha_obj, str_isalpha);
    1915                 :            : 
    1916                 :         22 : STATIC mp_obj_t str_isdigit(mp_obj_t self_in) {
    1917                 :         22 :     return str_uni_istype(unichar_isdigit, self_in);
    1918                 :            : }
    1919                 :            : MP_DEFINE_CONST_FUN_OBJ_1(str_isdigit_obj, str_isdigit);
    1920                 :            : 
    1921                 :         16 : STATIC mp_obj_t str_isupper(mp_obj_t self_in) {
    1922                 :         16 :     return str_uni_istype(unichar_isupper, self_in);
    1923                 :            : }
    1924                 :            : MP_DEFINE_CONST_FUN_OBJ_1(str_isupper_obj, str_isupper);
    1925                 :            : 
    1926                 :         24 : STATIC mp_obj_t str_islower(mp_obj_t self_in) {
    1927                 :         24 :     return str_uni_istype(unichar_islower, self_in);
    1928                 :            : }
    1929                 :            : MP_DEFINE_CONST_FUN_OBJ_1(str_islower_obj, str_islower);
    1930                 :            : 
    1931                 :            : #if MICROPY_CPYTHON_COMPAT
    1932                 :            : // These methods are superfluous in the presence of str() and bytes()
    1933                 :            : // constructors.
    1934                 :            : // TODO: should accept kwargs too
    1935                 :         10 : STATIC mp_obj_t bytes_decode(size_t n_args, const mp_obj_t *args) {
    1936                 :         10 :     mp_obj_t new_args[2];
    1937         [ +  - ]:         10 :     if (n_args == 1) {
    1938                 :         10 :         new_args[0] = args[0];
    1939                 :         10 :         new_args[1] = MP_OBJ_NEW_QSTR(MP_QSTR_utf_hyphen_8);
    1940                 :         10 :         args = new_args;
    1941                 :         10 :         n_args++;
    1942                 :            :     }
    1943                 :         10 :     return mp_obj_str_make_new(&mp_type_str, n_args, 0, args);
    1944                 :            : }
    1945                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bytes_decode_obj, 1, 3, bytes_decode);
    1946                 :            : 
    1947                 :            : // TODO: should accept kwargs too
    1948                 :         10 : STATIC mp_obj_t str_encode(size_t n_args, const mp_obj_t *args) {
    1949                 :         10 :     mp_obj_t new_args[2];
    1950         [ +  - ]:         10 :     if (n_args == 1) {
    1951                 :         10 :         new_args[0] = args[0];
    1952                 :         10 :         new_args[1] = MP_OBJ_NEW_QSTR(MP_QSTR_utf_hyphen_8);
    1953                 :         10 :         args = new_args;
    1954                 :         10 :         n_args++;
    1955                 :            :     }
    1956                 :         10 :     return bytes_make_new(NULL, n_args, 0, args);
    1957                 :            : }
    1958                 :            : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_encode_obj, 1, 3, str_encode);
    1959                 :            : #endif
    1960                 :            : 
    1961                 :            : #if MICROPY_PY_BUILTINS_BYTES_HEX
    1962                 :        108 : mp_obj_t mp_obj_bytes_hex(size_t n_args, const mp_obj_t *args, const mp_obj_type_t *type) {
    1963                 :            :     // First argument is the data to convert.
    1964                 :            :     // Second argument is an optional separator to be used between values.
    1965                 :        108 :     const char *sep = NULL;
    1966                 :        108 :     mp_buffer_info_t bufinfo;
    1967                 :        108 :     mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_READ);
    1968                 :            : 
    1969                 :            :     // Code below assumes non-zero buffer length when computing size with
    1970                 :            :     // separator, so handle the zero-length case here.
    1971         [ +  + ]:        108 :     if (bufinfo.len == 0) {
    1972                 :            :         return mp_const_empty_bytes;
    1973                 :            :     }
    1974                 :            : 
    1975                 :        106 :     vstr_t vstr;
    1976                 :        106 :     size_t out_len = bufinfo.len * 2;
    1977         [ +  + ]:        106 :     if (n_args > 1) {
    1978                 :            :         // 1-char separator between hex numbers
    1979                 :         50 :         out_len += bufinfo.len - 1;
    1980                 :         50 :         sep = mp_obj_str_get_str(args[1]);
    1981                 :            :     }
    1982                 :        106 :     vstr_init_len(&vstr, out_len);
    1983                 :        106 :     byte *in = bufinfo.buf, *out = (byte *)vstr.buf;
    1984         [ +  + ]:        918 :     for (mp_uint_t i = bufinfo.len; i--;) {
    1985                 :        812 :         byte d = (*in >> 4);
    1986         [ +  + ]:        812 :         if (d > 9) {
    1987                 :         26 :             d += 'a' - '9' - 1;
    1988                 :            :         }
    1989                 :        812 :         *out++ = d + '0';
    1990                 :        812 :         d = (*in++ & 0xf);
    1991         [ +  + ]:        812 :         if (d > 9) {
    1992                 :        208 :             d += 'a' - '9' - 1;
    1993                 :            :         }
    1994                 :        812 :         *out++ = d + '0';
    1995         [ +  + ]:        812 :         if (sep != NULL && i != 0) {
    1996                 :        328 :             *out++ = *sep;
    1997                 :            :         }
    1998                 :            :     }
    1999                 :        106 :     return mp_obj_new_str_type_from_vstr(type, &vstr);
    2000                 :            : }
    2001                 :            : 
    2002                 :         28 : mp_obj_t mp_obj_bytes_fromhex(mp_obj_t type_in, mp_obj_t data) {
    2003                 :         28 :     mp_buffer_info_t bufinfo;
    2004                 :         28 :     mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
    2005                 :            : 
    2006         [ +  + ]:         28 :     if ((bufinfo.len & 1) != 0) {
    2007                 :          2 :         mp_raise_ValueError(MP_ERROR_TEXT("odd-length string"));
    2008                 :            :     }
    2009                 :         26 :     vstr_t vstr;
    2010                 :         26 :     vstr_init_len(&vstr, bufinfo.len / 2);
    2011                 :         26 :     byte *in = bufinfo.buf, *out = (byte *)vstr.buf;
    2012                 :         26 :     byte hex_byte = 0;
    2013         [ +  + ]:        398 :     for (mp_uint_t i = bufinfo.len; i--;) {
    2014                 :        374 :         byte hex_ch = *in++;
    2015         [ +  + ]:        374 :         if (unichar_isxdigit(hex_ch)) {
    2016                 :        372 :             hex_byte += unichar_xdigit_value(hex_ch);
    2017                 :            :         } else {
    2018                 :          2 :             mp_raise_ValueError(MP_ERROR_TEXT("non-hex digit found"));
    2019                 :            :         }
    2020         [ +  + ]:        372 :         if (i & 1) {
    2021                 :        186 :             hex_byte <<= 4;
    2022                 :            :         } else {
    2023                 :        186 :             *out++ = hex_byte;
    2024                 :        186 :             hex_byte = 0;
    2025                 :            :         }
    2026                 :            :     }
    2027                 :         24 :     return mp_obj_new_str_type_from_vstr(MP_OBJ_TO_PTR(type_in), &vstr);
    2028                 :            : }
    2029                 :            : 
    2030                 :         96 : STATIC mp_obj_t bytes_hex_as_str(size_t n_args, const mp_obj_t *args) {
    2031                 :         96 :     return mp_obj_bytes_hex(n_args, args, &mp_type_str);
    2032                 :            : }
    2033                 :            : STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bytes_hex_as_str_obj, 1, 2, bytes_hex_as_str);
    2034                 :            : 
    2035                 :            : STATIC MP_DEFINE_CONST_FUN_OBJ_2(bytes_fromhex_obj, mp_obj_bytes_fromhex);
    2036                 :            : STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(bytes_fromhex_classmethod_obj, MP_ROM_PTR(&bytes_fromhex_obj));
    2037                 :            : #endif // MICROPY_PY_BUILTINS_BYTES_HEX
    2038                 :            : 
    2039                 :      75425 : mp_int_t mp_obj_str_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
    2040         [ +  + ]:      75425 :     if (flags == MP_BUFFER_READ) {
    2041         [ +  + ]:      75251 :         GET_STR_DATA_LEN(self_in, str_data, str_len);
    2042                 :      75251 :         bufinfo->buf = (void *)str_data;
    2043                 :      75251 :         bufinfo->len = str_len;
    2044                 :      75251 :         bufinfo->typecode = 'B'; // bytes should be unsigned, so should unicode byte-access
    2045                 :      75251 :         return 0;
    2046                 :            :     } else {
    2047                 :            :         // can't write to a string
    2048                 :            :         return 1;
    2049                 :            :     }
    2050                 :            : }
    2051                 :            : 
    2052                 :       3204 : void mp_obj_str_set_data(mp_obj_str_t *str, const byte *data, size_t len) {
    2053                 :       3204 :     str->data = data;
    2054                 :       3204 :     str->len = len;
    2055                 :       3204 :     str->hash = qstr_compute_hash(data, len);
    2056                 :       3204 : }
    2057                 :            : 
    2058                 :            : // This locals table is used for the following types: str, bytes, bytearray, array.array.
    2059                 :            : // Each type takes a different section (start to end offset) of this table.
    2060                 :            : STATIC const mp_rom_map_elem_t array_bytearray_str_bytes_locals_table[] = {
    2061                 :            :     #if MICROPY_PY_ARRAY || MICROPY_PY_BUILTINS_BYTEARRAY
    2062                 :            :     { MP_ROM_QSTR(MP_QSTR_append), MP_ROM_PTR(&mp_obj_array_append_obj) },
    2063                 :            :     { MP_ROM_QSTR(MP_QSTR_extend), MP_ROM_PTR(&mp_obj_array_extend_obj) },
    2064                 :            :     #endif
    2065                 :            :     #if MICROPY_PY_BUILTINS_BYTES_HEX
    2066                 :            :     { MP_ROM_QSTR(MP_QSTR_hex), MP_ROM_PTR(&bytes_hex_as_str_obj) },
    2067                 :            :     { MP_ROM_QSTR(MP_QSTR_fromhex), MP_ROM_PTR(&bytes_fromhex_classmethod_obj) },
    2068                 :            :     #endif
    2069                 :            :     #if MICROPY_CPYTHON_COMPAT
    2070                 :            :     { MP_ROM_QSTR(MP_QSTR_decode), MP_ROM_PTR(&bytes_decode_obj) },
    2071                 :            :     #endif
    2072                 :            :     { MP_ROM_QSTR(MP_QSTR_find), MP_ROM_PTR(&str_find_obj) },
    2073                 :            :     { MP_ROM_QSTR(MP_QSTR_rfind), MP_ROM_PTR(&str_rfind_obj) },
    2074                 :            :     { MP_ROM_QSTR(MP_QSTR_index), MP_ROM_PTR(&str_index_obj) },
    2075                 :            :     { MP_ROM_QSTR(MP_QSTR_rindex), MP_ROM_PTR(&str_rindex_obj) },
    2076                 :            :     { MP_ROM_QSTR(MP_QSTR_join), MP_ROM_PTR(&str_join_obj) },
    2077                 :            :     { MP_ROM_QSTR(MP_QSTR_split), MP_ROM_PTR(&str_split_obj) },
    2078                 :            :     #if MICROPY_PY_BUILTINS_STR_SPLITLINES
    2079                 :            :     { MP_ROM_QSTR(MP_QSTR_splitlines), MP_ROM_PTR(&str_splitlines_obj) },
    2080                 :            :     #endif
    2081                 :            :     { MP_ROM_QSTR(MP_QSTR_rsplit), MP_ROM_PTR(&str_rsplit_obj) },
    2082                 :            :     { MP_ROM_QSTR(MP_QSTR_startswith), MP_ROM_PTR(&str_startswith_obj) },
    2083                 :            :     { MP_ROM_QSTR(MP_QSTR_endswith), MP_ROM_PTR(&str_endswith_obj) },
    2084                 :            :     { MP_ROM_QSTR(MP_QSTR_strip), MP_ROM_PTR(&str_strip_obj) },
    2085                 :            :     { MP_ROM_QSTR(MP_QSTR_lstrip), MP_ROM_PTR(&str_lstrip_obj) },
    2086                 :            :     { MP_ROM_QSTR(MP_QSTR_rstrip), MP_ROM_PTR(&str_rstrip_obj) },
    2087                 :            :     { MP_ROM_QSTR(MP_QSTR_format), MP_ROM_PTR(&str_format_obj) },
    2088                 :            :     { MP_ROM_QSTR(MP_QSTR_replace), MP_ROM_PTR(&str_replace_obj) },
    2089                 :            :     #if MICROPY_PY_BUILTINS_STR_COUNT
    2090                 :            :     { MP_ROM_QSTR(MP_QSTR_count), MP_ROM_PTR(&str_count_obj) },
    2091                 :            :     #endif
    2092                 :            :     #if MICROPY_PY_BUILTINS_STR_PARTITION
    2093                 :            :     { MP_ROM_QSTR(MP_QSTR_partition), MP_ROM_PTR(&str_partition_obj) },
    2094                 :            :     { MP_ROM_QSTR(MP_QSTR_rpartition), MP_ROM_PTR(&str_rpartition_obj) },
    2095                 :            :     #endif
    2096                 :            :     #if MICROPY_PY_BUILTINS_STR_CENTER
    2097                 :            :     { MP_ROM_QSTR(MP_QSTR_center), MP_ROM_PTR(&str_center_obj) },
    2098                 :            :     #endif
    2099                 :            :     { MP_ROM_QSTR(MP_QSTR_lower), MP_ROM_PTR(&str_lower_obj) },
    2100                 :            :     { MP_ROM_QSTR(MP_QSTR_upper), MP_ROM_PTR(&str_upper_obj) },
    2101                 :            :     { MP_ROM_QSTR(MP_QSTR_isspace), MP_ROM_PTR(&str_isspace_obj) },
    2102                 :            :     { MP_ROM_QSTR(MP_QSTR_isalpha), MP_ROM_PTR(&str_isalpha_obj) },
    2103                 :            :     { MP_ROM_QSTR(MP_QSTR_isdigit), MP_ROM_PTR(&str_isdigit_obj) },
    2104                 :            :     { MP_ROM_QSTR(MP_QSTR_isupper), MP_ROM_PTR(&str_isupper_obj) },
    2105                 :            :     { MP_ROM_QSTR(MP_QSTR_islower), MP_ROM_PTR(&str_islower_obj) },
    2106                 :            :     #if MICROPY_CPYTHON_COMPAT
    2107                 :            :     { MP_ROM_QSTR(MP_QSTR_encode), MP_ROM_PTR(&str_encode_obj) },
    2108                 :            :     #endif
    2109                 :            : };
    2110                 :            : 
    2111                 :            : #if MICROPY_CPYTHON_COMPAT
    2112                 :            : #define TABLE_ENTRIES_COMPAT 1
    2113                 :            : #else
    2114                 :            : #define TABLE_ENTRIES_COMPAT 0
    2115                 :            : #endif
    2116                 :            : 
    2117                 :            : #if MICROPY_PY_BUILTINS_BYTES_HEX
    2118                 :            : #define TABLE_ENTRIES_HEX 2
    2119                 :            : #else
    2120                 :            : #define TABLE_ENTRIES_HEX 0
    2121                 :            : #endif
    2122                 :            : 
    2123                 :            : #if MICROPY_PY_ARRAY || MICROPY_PY_BUILTINS_BYTEARRAY
    2124                 :            : #define TABLE_ENTRIES_ARRAY 2
    2125                 :            : #else
    2126                 :            : #define TABLE_ENTRIES_ARRAY 0
    2127                 :            : #endif
    2128                 :            : 
    2129                 :            : MP_DEFINE_CONST_DICT_WITH_SIZE(mp_obj_str_locals_dict,
    2130                 :            :     array_bytearray_str_bytes_locals_table + TABLE_ENTRIES_ARRAY + TABLE_ENTRIES_HEX + TABLE_ENTRIES_COMPAT,
    2131                 :            :     MP_ARRAY_SIZE(array_bytearray_str_bytes_locals_table) - (TABLE_ENTRIES_ARRAY + TABLE_ENTRIES_HEX + TABLE_ENTRIES_COMPAT));
    2132                 :            : 
    2133                 :            : #if TABLE_ENTRIES_COMPAT == 0
    2134                 :            : #define mp_obj_bytes_locals_dict mp_obj_str_locals_dict
    2135                 :            : #else
    2136                 :            : MP_DEFINE_CONST_DICT_WITH_SIZE(mp_obj_bytes_locals_dict,
    2137                 :            :     array_bytearray_str_bytes_locals_table + TABLE_ENTRIES_ARRAY,
    2138                 :            :     MP_ARRAY_SIZE(array_bytearray_str_bytes_locals_table) - (TABLE_ENTRIES_ARRAY + TABLE_ENTRIES_COMPAT));
    2139                 :            : #endif
    2140                 :            : 
    2141                 :            : #if MICROPY_PY_BUILTINS_BYTEARRAY
    2142                 :            : MP_DEFINE_CONST_DICT_WITH_SIZE(mp_obj_bytearray_locals_dict,
    2143                 :            :     array_bytearray_str_bytes_locals_table,
    2144                 :            :     MP_ARRAY_SIZE(array_bytearray_str_bytes_locals_table) - TABLE_ENTRIES_COMPAT);
    2145                 :            : #endif
    2146                 :            : 
    2147                 :            : #if MICROPY_PY_ARRAY
    2148                 :            : MP_DEFINE_CONST_DICT_WITH_SIZE(mp_obj_array_locals_dict,
    2149                 :            :     array_bytearray_str_bytes_locals_table,
    2150                 :            :     TABLE_ENTRIES_ARRAY);
    2151                 :            : #endif
    2152                 :            : 
    2153                 :            : #if MICROPY_PY_BUILTINS_MEMORYVIEW && MICROPY_PY_BUILTINS_BYTES_HEX
    2154                 :            : MP_DEFINE_CONST_DICT_WITH_SIZE(mp_obj_memoryview_locals_dict,
    2155                 :            :     array_bytearray_str_bytes_locals_table + TABLE_ENTRIES_ARRAY,
    2156                 :            :     1); // Just the "hex" entry.
    2157                 :            : #endif
    2158                 :            : 
    2159                 :            : #if !MICROPY_PY_BUILTINS_STR_UNICODE
    2160                 :            : STATIC mp_obj_t mp_obj_new_str_iterator(mp_obj_t str, mp_obj_iter_buf_t *iter_buf);
    2161                 :            : 
    2162                 :            : MP_DEFINE_CONST_OBJ_TYPE(
    2163                 :            :     mp_type_str,
    2164                 :            :     MP_QSTR_str,
    2165                 :            :     MP_TYPE_FLAG_NONE,
    2166                 :            :     make_new, mp_obj_str_make_new,
    2167                 :            :     print, str_print,
    2168                 :            :     binary_op, mp_obj_str_binary_op,
    2169                 :            :     subscr, bytes_subscr,
    2170                 :            :     iter, mp_obj_new_str_iterator,
    2171                 :            :     buffer, mp_obj_str_get_buffer,
    2172                 :            :     locals_dict, &mp_obj_str_locals_dict
    2173                 :            :     );
    2174                 :            : #endif // !MICROPY_PY_BUILTINS_STR_UNICODE
    2175                 :            : 
    2176                 :            : // Reuses most methods from str
    2177                 :            : MP_DEFINE_CONST_OBJ_TYPE(
    2178                 :            :     mp_type_bytes,
    2179                 :            :     MP_QSTR_bytes,
    2180                 :            :     MP_TYPE_FLAG_NONE,
    2181                 :            :     make_new, bytes_make_new,
    2182                 :            :     print, str_print,
    2183                 :            :     binary_op, mp_obj_str_binary_op,
    2184                 :            :     subscr, bytes_subscr,
    2185                 :            :     iter, mp_obj_new_bytes_iterator,
    2186                 :            :     buffer, mp_obj_str_get_buffer,
    2187                 :            :     locals_dict, &mp_obj_bytes_locals_dict
    2188                 :            :     );
    2189                 :            : 
    2190                 :            : // The zero-length bytes object, with data that includes a null-terminating byte
    2191                 :            : const mp_obj_str_t mp_const_empty_bytes_obj = {{&mp_type_bytes}, 0, 0, (const byte *)""};
    2192                 :            : 
    2193                 :            : // Create a str/bytes object using the given data.  New memory is allocated and
    2194                 :            : // the data is copied across.  This function should only be used if the type is bytes,
    2195                 :            : // or if the type is str and the string data is known to be not interned.
    2196                 :      11316 : mp_obj_t mp_obj_new_str_copy(const mp_obj_type_t *type, const byte *data, size_t len) {
    2197                 :      11316 :     mp_obj_str_t *o = mp_obj_malloc(mp_obj_str_t, type);
    2198                 :      11316 :     o->len = len;
    2199         [ +  + ]:      11316 :     if (data) {
    2200                 :      11282 :         o->hash = qstr_compute_hash(data, len);
    2201                 :      11282 :         byte *p = m_new(byte, len + 1);
    2202                 :      11282 :         o->data = p;
    2203                 :      11282 :         memcpy(p, data, len * sizeof(byte));
    2204                 :      11282 :         p[len] = '\0'; // for now we add null for compatibility with C ASCIIZ strings
    2205                 :            :     }
    2206                 :      11316 :     return MP_OBJ_FROM_PTR(o);
    2207                 :            : }
    2208                 :            : 
    2209                 :            : // Create a str/bytes object using the given data.  If the type is str and the string
    2210                 :            : // data is already interned, then a qstr object is returned.  Otherwise new memory is
    2211                 :            : // allocated for the object and the data is copied across.
    2212                 :       6468 : mp_obj_t mp_obj_new_str_of_type(const mp_obj_type_t *type, const byte *data, size_t len) {
    2213         [ +  + ]:       6468 :     if (type == &mp_type_str) {
    2214                 :       5998 :         return mp_obj_new_str((const char *)data, len);
    2215                 :            :     #if MICROPY_PY_BUILTINS_BYTEARRAY
    2216         [ +  + ]:        470 :     } else if (type == &mp_type_bytearray) {
    2217                 :         64 :         return mp_obj_new_bytearray(len, data);
    2218                 :            :     #endif
    2219                 :            :     } else {
    2220                 :        406 :         return mp_obj_new_bytes(data, len);
    2221                 :            :     }
    2222                 :            : }
    2223                 :            : 
    2224                 :            : // Create a str using a qstr to store the data; may use existing or new qstr.
    2225                 :      29614 : mp_obj_t mp_obj_new_str_via_qstr(const char *data, size_t len) {
    2226                 :      29614 :     return MP_OBJ_NEW_QSTR(qstr_from_strn(data, len));
    2227                 :            : }
    2228                 :            : 
    2229                 :            : // Create a str/bytes object from the given vstr.  The vstr buffer is resized to
    2230                 :            : // the exact length required and then reused for the str/bytes object.  The vstr
    2231                 :            : // is cleared and can safely be passed to vstr_free if it was heap allocated.
    2232                 :     282386 : STATIC mp_obj_t mp_obj_new_str_type_from_vstr(const mp_obj_type_t *type, vstr_t *vstr) {
    2233                 :            :     // if not a bytes object, look if a qstr with this data already exists
    2234         [ +  + ]:     282386 :     if (type == &mp_type_str) {
    2235                 :     280419 :         qstr q = qstr_find_strn(vstr->buf, vstr->len);
    2236         [ +  + ]:     280419 :         if (q != MP_QSTRnull) {
    2237                 :       7633 :             vstr_clear(vstr);
    2238                 :       7633 :             vstr->alloc = 0;
    2239                 :       7633 :             return MP_OBJ_NEW_QSTR(q);
    2240                 :            :         }
    2241                 :            :     }
    2242                 :            : 
    2243                 :     274753 :     byte *data;
    2244         [ +  + ]:     274753 :     if (vstr->len + 1 == vstr->alloc) {
    2245                 :      75791 :         data = (byte *)vstr->buf;
    2246                 :            :     } else {
    2247                 :     198962 :         data = (byte *)m_renew(char, vstr->buf, vstr->alloc, vstr->len + 1);
    2248                 :            :     }
    2249                 :     274753 :     data[vstr->len] = '\0'; // add null byte
    2250                 :     274753 :     vstr->buf = NULL;
    2251                 :     274753 :     vstr->alloc = 0;
    2252                 :            :     #if MICROPY_PY_BUILTINS_BYTEARRAY
    2253         [ +  + ]:     274753 :     if (type == &mp_type_bytearray) {
    2254                 :         28 :         return mp_obj_new_bytearray_by_ref(vstr->len, data);
    2255                 :            :     }
    2256                 :            :     #endif
    2257                 :     274725 :     mp_obj_str_t *o = mp_obj_malloc(mp_obj_str_t, type);
    2258                 :     274725 :     o->len = vstr->len;
    2259                 :     274725 :     o->hash = qstr_compute_hash(data, vstr->len);
    2260                 :     274725 :     o->data = data;
    2261                 :     274725 :     return MP_OBJ_FROM_PTR(o);
    2262                 :            : }
    2263                 :            : 
    2264                 :        197 : mp_obj_t mp_obj_new_str_from_vstr(vstr_t *vstr) {
    2265                 :            :     #if MICROPY_PY_BUILTINS_STR_UNICODE && MICROPY_PY_BUILTINS_STR_UNICODE_CHECK
    2266         [ +  + ]:        197 :     if (!utf8_check((byte *)vstr->buf, vstr->len)) {
    2267                 :          2 :         mp_raise_msg(&mp_type_UnicodeError, NULL);
    2268                 :            :     }
    2269                 :            :     #endif // MICROPY_PY_BUILTINS_STR_UNICODE && MICROPY_PY_BUILTINS_STR_UNICODE_CHECK
    2270                 :        195 :     return mp_obj_new_str_type_from_vstr(&mp_type_str, vstr);
    2271                 :            : }
    2272                 :            : 
    2273                 :            : #if MICROPY_PY_BUILTINS_STR_UNICODE && MICROPY_PY_BUILTINS_STR_UNICODE_CHECK
    2274                 :       5146 : mp_obj_t mp_obj_new_str_from_utf8_vstr(vstr_t *vstr) {
    2275                 :            :     // bypasses utf8_check.
    2276                 :       5146 :     return mp_obj_new_str_type_from_vstr(&mp_type_str, vstr);
    2277                 :            : }
    2278                 :            : #endif // MICROPY_PY_BUILTINS_STR_UNICODE && MICROPY_PY_BUILTINS_STR_UNICODE_CHECK
    2279                 :            : 
    2280                 :       1185 : mp_obj_t mp_obj_new_bytes_from_vstr(vstr_t *vstr) {
    2281                 :       1185 :     return mp_obj_new_str_type_from_vstr(&mp_type_bytes, vstr);
    2282                 :            : }
    2283                 :            : 
    2284                 :      11647 : mp_obj_t mp_obj_new_str(const char *data, size_t len) {
    2285                 :            :     #if MICROPY_PY_BUILTINS_STR_UNICODE && MICROPY_PY_BUILTINS_STR_UNICODE_CHECK
    2286         [ +  + ]:      11647 :     if (!utf8_check((byte *)data, len)) {
    2287                 :          2 :         mp_raise_msg(&mp_type_UnicodeError, NULL);
    2288                 :            :     }
    2289                 :            :     #endif
    2290                 :      11645 :     qstr q = qstr_find_strn(data, len);
    2291         [ +  + ]:      11645 :     if (q != MP_QSTRnull) {
    2292                 :            :         // qstr with this data already exists
    2293                 :       5160 :         return MP_OBJ_NEW_QSTR(q);
    2294                 :            :     } else {
    2295                 :            :         // no existing qstr, don't make one
    2296                 :       6485 :         return mp_obj_new_str_copy(&mp_type_str, (const byte *)data, len);
    2297                 :            :     }
    2298                 :            : }
    2299                 :            : 
    2300                 :          2 : mp_obj_t mp_obj_str_intern(mp_obj_t str) {
    2301         [ -  + ]:          2 :     GET_STR_DATA_LEN(str, data, len);
    2302                 :          2 :     return mp_obj_new_str_via_qstr((const char *)data, len);
    2303                 :            : }
    2304                 :            : 
    2305                 :        418 : mp_obj_t mp_obj_str_intern_checked(mp_obj_t obj) {
    2306                 :        418 :     size_t len;
    2307                 :        418 :     const char *data = mp_obj_str_get_data(obj, &len);
    2308                 :        414 :     return mp_obj_new_str_via_qstr((const char *)data, len);
    2309                 :            : }
    2310                 :            : 
    2311                 :       2578 : mp_obj_t mp_obj_new_bytes(const byte *data, size_t len) {
    2312                 :       2578 :     return mp_obj_new_str_copy(&mp_type_bytes, data, len);
    2313                 :            : }
    2314                 :            : 
    2315                 :     268810 : bool mp_obj_str_equal(mp_obj_t s1, mp_obj_t s2) {
    2316   [ +  +  +  + ]:     268810 :     if (mp_obj_is_qstr(s1) && mp_obj_is_qstr(s2)) {
    2317                 :       4624 :         return s1 == s2;
    2318                 :            :     } else {
    2319         [ +  + ]:     264186 :         GET_STR_HASH(s1, h1);
    2320         [ +  + ]:     264186 :         GET_STR_HASH(s2, h2);
    2321                 :            :         // If any of hashes is 0, it means it's not valid
    2322   [ +  +  +  + ]:     264186 :         if (h1 != 0 && h2 != 0 && h1 != h2) {
    2323                 :            :             return false;
    2324                 :            :         }
    2325         [ +  + ]:      21230 :         GET_STR_DATA_LEN(s1, d1, l1);
    2326         [ +  + ]:      21230 :         GET_STR_DATA_LEN(s2, d2, l2);
    2327         [ +  + ]:      21230 :         if (l1 != l2) {
    2328                 :            :             return false;
    2329                 :            :         }
    2330                 :      21224 :         return memcmp(d1, d2, l1) == 0;
    2331                 :            :     }
    2332                 :            : }
    2333                 :            : 
    2334                 :        106 : STATIC NORETURN void bad_implicit_conversion(mp_obj_t self_in) {
    2335                 :            :     #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
    2336                 :            :     mp_raise_TypeError(MP_ERROR_TEXT("can't convert to str implicitly"));
    2337                 :            :     #else
    2338                 :        106 :     const qstr src_name = mp_obj_get_type(self_in)->name;
    2339         [ +  + ]:        106 :     mp_raise_msg_varg(&mp_type_TypeError,
    2340                 :        106 :         MP_ERROR_TEXT("can't convert '%q' object to %q implicitly"),
    2341                 :            :         src_name, src_name == MP_QSTR_str ? MP_QSTR_bytes : MP_QSTR_str);
    2342                 :            :     #endif
    2343                 :            : }
    2344                 :            : 
    2345                 :            : // use this if you will anyway convert the string to a qstr
    2346                 :            : // will be more efficient for the case where it's already a qstr
    2347                 :       4456 : qstr mp_obj_str_get_qstr(mp_obj_t self_in) {
    2348         [ +  + ]:       4456 :     if (mp_obj_is_qstr(self_in)) {
    2349                 :       4418 :         return MP_OBJ_QSTR_VALUE(self_in);
    2350   [ +  +  +  + ]:         38 :     } else if (mp_obj_is_exact_type(self_in, &mp_type_str)) {
    2351                 :         26 :         mp_obj_str_t *self = MP_OBJ_TO_PTR(self_in);
    2352                 :         26 :         return qstr_from_strn((char *)self->data, self->len);
    2353                 :            :     } else {
    2354                 :         12 :         bad_implicit_conversion(self_in);
    2355                 :            :     }
    2356                 :            : }
    2357                 :            : 
    2358                 :            : // only use this function if you need the str data to be zero terminated
    2359                 :            : // at the moment all strings are zero terminated to help with C ASCIIZ compatibility
    2360                 :      24769 : const char *mp_obj_str_get_str(mp_obj_t self_in) {
    2361   [ +  +  +  +  :      24769 :     if (mp_obj_is_str_or_bytes(self_in)) {
             +  -  +  - ]
    2362         [ +  + ]:      24759 :         GET_STR_DATA_LEN(self_in, s, l);
    2363                 :      24759 :         (void)l; // len unused
    2364                 :      24759 :         return (const char *)s;
    2365                 :            :     } else {
    2366                 :         10 :         bad_implicit_conversion(self_in);
    2367                 :            :     }
    2368                 :            : }
    2369                 :            : 
    2370                 :     334538 : const char *mp_obj_str_get_data(mp_obj_t self_in, size_t *len) {
    2371   [ +  +  +  +  :     334538 :     if (mp_obj_is_str_or_bytes(self_in)) {
             +  +  +  + ]
    2372         [ +  + ]:     334510 :         GET_STR_DATA_LEN(self_in, s, l);
    2373                 :     334509 :         *len = l;
    2374                 :     334509 :         return (const char *)s;
    2375                 :            :     } else {
    2376                 :         28 :         bad_implicit_conversion(self_in);
    2377                 :            :     }
    2378                 :            : }
    2379                 :            : 
    2380                 :            : #if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
    2381                 :            : const byte *mp_obj_str_get_data_no_check(mp_obj_t self_in, size_t *len) {
    2382                 :            :     if (mp_obj_is_qstr(self_in)) {
    2383                 :            :         return qstr_data(MP_OBJ_QSTR_VALUE(self_in), len);
    2384                 :            :     } else {
    2385                 :            :         MP_STATIC_ASSERT_STR_ARRAY_COMPATIBLE;
    2386                 :            :         *len = ((mp_obj_str_t *)MP_OBJ_TO_PTR(self_in))->len;
    2387                 :            :         return ((mp_obj_str_t *)MP_OBJ_TO_PTR(self_in))->data;
    2388                 :            :     }
    2389                 :            : }
    2390                 :            : #endif
    2391                 :            : 
    2392                 :            : /******************************************************************************/
    2393                 :            : /* str iterator                                                               */
    2394                 :            : 
    2395                 :            : typedef struct _mp_obj_str8_it_t {
    2396                 :            :     mp_obj_base_t base;
    2397                 :            :     mp_fun_1_t iternext;
    2398                 :            :     mp_obj_t str;
    2399                 :            :     size_t cur;
    2400                 :            : } mp_obj_str8_it_t;
    2401                 :            : 
    2402                 :            : #if !MICROPY_PY_BUILTINS_STR_UNICODE
    2403                 :            : STATIC mp_obj_t str_it_iternext(mp_obj_t self_in) {
    2404                 :            :     mp_obj_str8_it_t *self = MP_OBJ_TO_PTR(self_in);
    2405                 :            :     GET_STR_DATA_LEN(self->str, str, len);
    2406                 :            :     if (self->cur < len) {
    2407                 :            :         mp_obj_t o_out = mp_obj_new_str_via_qstr((const char *)str + self->cur, 1);
    2408                 :            :         self->cur += 1;
    2409                 :            :         return o_out;
    2410                 :            :     } else {
    2411                 :            :         return MP_OBJ_STOP_ITERATION;
    2412                 :            :     }
    2413                 :            : }
    2414                 :            : 
    2415                 :            : STATIC mp_obj_t mp_obj_new_str_iterator(mp_obj_t str, mp_obj_iter_buf_t *iter_buf) {
    2416                 :            :     assert(sizeof(mp_obj_str8_it_t) <= sizeof(mp_obj_iter_buf_t));
    2417                 :            :     mp_obj_str8_it_t *o = (mp_obj_str8_it_t *)iter_buf;
    2418                 :            :     o->base.type = &mp_type_polymorph_iter;
    2419                 :            :     o->iternext = str_it_iternext;
    2420                 :            :     o->str = str;
    2421                 :            :     o->cur = 0;
    2422                 :            :     return MP_OBJ_FROM_PTR(o);
    2423                 :            : }
    2424                 :            : #endif
    2425                 :            : 
    2426                 :         92 : STATIC mp_obj_t bytes_it_iternext(mp_obj_t self_in) {
    2427                 :         92 :     mp_obj_str8_it_t *self = MP_OBJ_TO_PTR(self_in);
    2428         [ -  + ]:         92 :     GET_STR_DATA_LEN(self->str, str, len);
    2429         [ +  + ]:         92 :     if (self->cur < len) {
    2430                 :         72 :         mp_obj_t o_out = MP_OBJ_NEW_SMALL_INT(str[self->cur]);
    2431                 :         72 :         self->cur += 1;
    2432                 :         72 :         return o_out;
    2433                 :            :     } else {
    2434                 :            :         return MP_OBJ_STOP_ITERATION;
    2435                 :            :     }
    2436                 :            : }
    2437                 :            : 
    2438                 :         28 : mp_obj_t mp_obj_new_bytes_iterator(mp_obj_t str, mp_obj_iter_buf_t *iter_buf) {
    2439                 :         28 :     assert(sizeof(mp_obj_str8_it_t) <= sizeof(mp_obj_iter_buf_t));
    2440                 :         28 :     mp_obj_str8_it_t *o = (mp_obj_str8_it_t *)iter_buf;
    2441                 :         28 :     o->base.type = &mp_type_polymorph_iter;
    2442                 :         28 :     o->iternext = bytes_it_iternext;
    2443                 :         28 :     o->str = str;
    2444                 :         28 :     o->cur = 0;
    2445                 :         28 :     return MP_OBJ_FROM_PTR(o);
    2446                 :            : }

Generated by: LCOV version 1.15-5-g462f71d