LCOV - code coverage report
Current view: top level - py - objint_mpz.c (source / functions) Hit Total Coverage
Test: unix_coverage_v1.19.1-724-gfb7d21153.info Lines: 218 218 100.0 %
Date: 2022-12-01 09:37:31 Functions: 18 18 100.0 %
Branches: 140 160 87.5 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * This file is part of the MicroPython project, http://micropython.org/
       3                 :            :  *
       4                 :            :  * The MIT License (MIT)
       5                 :            :  *
       6                 :            :  * Copyright (c) 2013, 2014 Damien P. George
       7                 :            :  *
       8                 :            :  * Permission is hereby granted, free of charge, to any person obtaining a copy
       9                 :            :  * of this software and associated documentation files (the "Software"), to deal
      10                 :            :  * in the Software without restriction, including without limitation the rights
      11                 :            :  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      12                 :            :  * copies of the Software, and to permit persons to whom the Software is
      13                 :            :  * furnished to do so, subject to the following conditions:
      14                 :            :  *
      15                 :            :  * The above copyright notice and this permission notice shall be included in
      16                 :            :  * all copies or substantial portions of the Software.
      17                 :            :  *
      18                 :            :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      19                 :            :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      20                 :            :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      21                 :            :  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      22                 :            :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      23                 :            :  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
      24                 :            :  * THE SOFTWARE.
      25                 :            :  */
      26                 :            : 
      27                 :            : #include <string.h>
      28                 :            : #include <stdio.h>
      29                 :            : #include <assert.h>
      30                 :            : 
      31                 :            : #include "py/parsenumbase.h"
      32                 :            : #include "py/smallint.h"
      33                 :            : #include "py/objint.h"
      34                 :            : #include "py/runtime.h"
      35                 :            : 
      36                 :            : #if MICROPY_PY_BUILTINS_FLOAT
      37                 :            : #include <math.h>
      38                 :            : #endif
      39                 :            : 
      40                 :            : #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_MPZ
      41                 :            : 
      42                 :            : #if MICROPY_PY_SYS_MAXSIZE
      43                 :            : // Export value for sys.maxsize
      44                 :            : // *FORMAT-OFF*
      45                 :            : #define DIG_MASK ((MPZ_LONG_1 << MPZ_DIG_SIZE) - 1)
      46                 :            : STATIC const mpz_dig_t maxsize_dig[] = {
      47                 :            :     #define NUM_DIG 1
      48                 :            :     (MP_SSIZE_MAX >> MPZ_DIG_SIZE * 0) & DIG_MASK,
      49                 :            :     #if (MP_SSIZE_MAX >> MPZ_DIG_SIZE * 0) > DIG_MASK
      50                 :            :      #undef NUM_DIG
      51                 :            :      #define NUM_DIG 2
      52                 :            :      (MP_SSIZE_MAX >> MPZ_DIG_SIZE * 1) & DIG_MASK,
      53                 :            :      #if (MP_SSIZE_MAX >> MPZ_DIG_SIZE * 1) > DIG_MASK
      54                 :            :       #undef NUM_DIG
      55                 :            :       #define NUM_DIG 3
      56                 :            :       (MP_SSIZE_MAX >> MPZ_DIG_SIZE * 2) & DIG_MASK,
      57                 :            :       #if (MP_SSIZE_MAX >> MPZ_DIG_SIZE * 2) > DIG_MASK
      58                 :            :        #undef NUM_DIG
      59                 :            :        #define NUM_DIG 4
      60                 :            :        (MP_SSIZE_MAX >> MPZ_DIG_SIZE * 3) & DIG_MASK,
      61                 :            :        #if (MP_SSIZE_MAX >> MPZ_DIG_SIZE * 3) > DIG_MASK
      62                 :            :         #error cannot encode MP_SSIZE_MAX as mpz
      63                 :            :        #endif
      64                 :            :       #endif
      65                 :            :      #endif
      66                 :            :     #endif
      67                 :            : };
      68                 :            : // *FORMAT-ON*
      69                 :            : const mp_obj_int_t mp_sys_maxsize_obj = {
      70                 :            :     {&mp_type_int},
      71                 :            :     {.fixed_dig = 1, .len = NUM_DIG, .alloc = NUM_DIG, .dig = (mpz_dig_t *)maxsize_dig}
      72                 :            : };
      73                 :            : #undef DIG_MASK
      74                 :            : #undef NUM_DIG
      75                 :            : #endif
      76                 :            : 
      77                 :      32218 : mp_obj_int_t *mp_obj_int_new_mpz(void) {
      78                 :      32218 :     mp_obj_int_t *o = mp_obj_malloc(mp_obj_int_t, &mp_type_int);
      79                 :      32222 :     mpz_init_zero(&o->mpz);
      80                 :      32225 :     return o;
      81                 :            : }
      82                 :            : 
      83                 :            : // This routine expects you to pass in a buffer and size (in *buf and buf_size).
      84                 :            : // If, for some reason, this buffer is too small, then it will allocate a
      85                 :            : // buffer and return the allocated buffer and size in *buf and *buf_size. It
      86                 :            : // is the callers responsibility to free this allocated buffer.
      87                 :            : //
      88                 :            : // The resulting formatted string will be returned from this function and the
      89                 :            : // formatted size will be in *fmt_size.
      90                 :            : //
      91                 :            : // This particular routine should only be called for the mpz representation of the int.
      92                 :      41074 : char *mp_obj_int_formatted_impl(char **buf, size_t *buf_size, size_t *fmt_size, mp_const_obj_t self_in,
      93                 :            :     int base, const char *prefix, char base_char, char comma) {
      94   [ +  -  -  + ]:      41074 :     assert(mp_obj_is_exact_type(self_in, &mp_type_int));
      95                 :      41074 :     const mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in);
      96                 :            : 
      97                 :      41074 :     size_t needed_size = mp_int_format_size(mpz_max_num_bits(&self->mpz), base, prefix, comma);
      98         [ +  + ]:      41074 :     if (needed_size > *buf_size) {
      99                 :      12908 :         *buf = m_new(char, needed_size);
     100                 :      12908 :         *buf_size = needed_size;
     101                 :            :     }
     102                 :      41074 :     char *str = *buf;
     103                 :            : 
     104                 :      41074 :     *fmt_size = mpz_as_str_inpl(&self->mpz, base, prefix, base_char, comma, str);
     105                 :            : 
     106                 :      41074 :     return str;
     107                 :            : }
     108                 :            : 
     109                 :         16 : mp_obj_t mp_obj_int_from_bytes_impl(bool big_endian, size_t len, const byte *buf) {
     110                 :         16 :     mp_obj_int_t *o = mp_obj_int_new_mpz();
     111                 :         16 :     mpz_set_from_bytes(&o->mpz, big_endian, len, buf);
     112                 :         16 :     return MP_OBJ_FROM_PTR(o);
     113                 :            : }
     114                 :            : 
     115                 :         72 : void mp_obj_int_to_bytes_impl(mp_obj_t self_in, bool big_endian, size_t len, byte *buf) {
     116   [ +  -  -  + ]:         72 :     assert(mp_obj_is_exact_type(self_in, &mp_type_int));
     117                 :         72 :     mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in);
     118                 :         72 :     mpz_as_bytes(&self->mpz, big_endian, len, buf);
     119                 :         72 : }
     120                 :            : 
     121                 :      78891 : int mp_obj_int_sign(mp_obj_t self_in) {
     122         [ +  + ]:      78891 :     if (mp_obj_is_small_int(self_in)) {
     123                 :      74401 :         mp_int_t val = MP_OBJ_SMALL_INT_VALUE(self_in);
     124         [ +  + ]:      74401 :         if (val < 0) {
     125                 :            :             return -1;
     126         [ +  + ]:      73545 :         } else if (val > 0) {
     127                 :            :             return 1;
     128                 :            :         } else {
     129                 :      37299 :             return 0;
     130                 :            :         }
     131                 :            :     }
     132                 :       4490 :     mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in);
     133         [ +  + ]:       4490 :     if (self->mpz.len == 0) {
     134                 :            :         return 0;
     135         [ +  + ]:       4480 :     } else if (self->mpz.neg == 0) {
     136                 :            :         return 1;
     137                 :            :     } else {
     138                 :          2 :         return -1;
     139                 :            :     }
     140                 :            : }
     141                 :            : 
     142                 :       1496 : mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
     143                 :       1496 :     mp_obj_int_t *o = MP_OBJ_TO_PTR(o_in);
     144   [ +  +  +  +  :       1496 :     switch (op) {
                +  +  + ]
     145                 :        814 :         case MP_UNARY_OP_BOOL:
     146         [ +  + ]:        814 :             return mp_obj_new_bool(!mpz_is_zero(&o->mpz));
     147                 :         12 :         case MP_UNARY_OP_HASH:
     148                 :         12 :             return MP_OBJ_NEW_SMALL_INT(mpz_hash(&o->mpz));
     149                 :            :         case MP_UNARY_OP_POSITIVE:
     150                 :            :             return o_in;
     151                 :        580 :         case MP_UNARY_OP_NEGATIVE: { mp_obj_int_t *o2 = mp_obj_int_new_mpz();
     152                 :        580 :                                      mpz_neg_inpl(&o2->mpz, &o->mpz);
     153                 :        580 :                                      return MP_OBJ_FROM_PTR(o2);
     154                 :            :         }
     155                 :         72 :         case MP_UNARY_OP_INVERT: { mp_obj_int_t *o2 = mp_obj_int_new_mpz();
     156                 :         72 :                                    mpz_not_inpl(&o2->mpz, &o->mpz);
     157                 :         72 :                                    return MP_OBJ_FROM_PTR(o2);
     158                 :            :         }
     159                 :         10 :         case MP_UNARY_OP_ABS: {
     160                 :         10 :             mp_obj_int_t *self = MP_OBJ_TO_PTR(o_in);
     161         [ +  + ]:         10 :             if (self->mpz.neg == 0) {
     162                 :            :                 return o_in;
     163                 :            :             }
     164                 :          6 :             mp_obj_int_t *self2 = mp_obj_int_new_mpz();
     165                 :          6 :             mpz_abs_inpl(&self2->mpz, &self->mpz);
     166                 :          6 :             return MP_OBJ_FROM_PTR(self2);
     167                 :            :         }
     168                 :          4 :         default:
     169                 :          4 :             return MP_OBJ_NULL;      // op not supported
     170                 :            :     }
     171                 :            : }
     172                 :            : 
     173                 :      43505 : mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
     174                 :      43505 :     const mpz_t *zlhs;
     175                 :      43505 :     const mpz_t *zrhs;
     176                 :      43505 :     mpz_t z_int;
     177                 :      43505 :     mpz_dig_t z_int_dig[MPZ_NUM_DIG_FOR_INT];
     178                 :            : 
     179                 :            :     // lhs could be a small int (eg small-int + mpz)
     180         [ +  + ]:      43505 :     if (mp_obj_is_small_int(lhs_in)) {
     181                 :       1717 :         mpz_init_fixed_from_int(&z_int, z_int_dig, MPZ_NUM_DIG_FOR_INT, MP_OBJ_SMALL_INT_VALUE(lhs_in));
     182                 :       1717 :         zlhs = &z_int;
     183                 :            :     } else {
     184   [ +  -  -  + ]:      41788 :         assert(mp_obj_is_exact_type(lhs_in, &mp_type_int));
     185                 :      41788 :         zlhs = &((mp_obj_int_t *)MP_OBJ_TO_PTR(lhs_in))->mpz;
     186                 :            :     }
     187                 :            : 
     188                 :            :     // if rhs is small int, then lhs was not (otherwise mp_binary_op handles it)
     189         [ +  + ]:      43505 :     if (mp_obj_is_small_int(rhs_in)) {
     190                 :      26780 :         mpz_init_fixed_from_int(&z_int, z_int_dig, MPZ_NUM_DIG_FOR_INT, MP_OBJ_SMALL_INT_VALUE(rhs_in));
     191                 :      26780 :         zrhs = &z_int;
     192   [ +  +  +  + ]:      16725 :     } else if (mp_obj_is_exact_type(rhs_in, &mp_type_int)) {
     193                 :      16246 :         zrhs = &((mp_obj_int_t *)MP_OBJ_TO_PTR(rhs_in))->mpz;
     194                 :            :     #if MICROPY_PY_BUILTINS_FLOAT
     195   [ -  +  -  +  :        479 :     } else if (mp_obj_is_float(rhs_in)) {
          -  +  -  +  +  
                +  +  + ]
     196                 :          8 :         return mp_obj_float_binary_op(op, mpz_as_float(zlhs), rhs_in);
     197                 :            :     #endif
     198                 :            :     #if MICROPY_PY_BUILTINS_COMPLEX
     199   [ -  +  -  +  :        471 :     } else if (mp_obj_is_type(rhs_in, &mp_type_complex)) {
          -  +  -  +  +  
                +  +  + ]
     200                 :          4 :         return mp_obj_complex_binary_op(op, mpz_as_float(zlhs), 0, rhs_in);
     201                 :            :     #endif
     202                 :            :     } else {
     203                 :            :         // delegate to generic function to check for extra cases
     204                 :        467 :         return mp_obj_int_binary_op_extra_cases(op, lhs_in, rhs_in);
     205                 :            :     }
     206                 :            : 
     207                 :            :     #if MICROPY_PY_BUILTINS_FLOAT
     208         [ +  + ]:      43022 :     if (op == MP_BINARY_OP_TRUE_DIVIDE || op == MP_BINARY_OP_INPLACE_TRUE_DIVIDE) {
     209         [ +  + ]:          8 :         if (mpz_is_zero(zrhs)) {
     210                 :          4 :             goto zero_division_error;
     211                 :            :         }
     212                 :          4 :         mp_float_t flhs = mpz_as_float(zlhs);
     213                 :          4 :         mp_float_t frhs = mpz_as_float(zrhs);
     214                 :          4 :         return mp_obj_new_float(flhs / frhs);
     215                 :            :     }
     216                 :            :     #endif
     217                 :            : 
     218         [ +  + ]:      43014 :     if (op >= MP_BINARY_OP_INPLACE_OR && op < MP_BINARY_OP_CONTAINS) {
     219                 :      24590 :         mp_obj_int_t *res = mp_obj_int_new_mpz();
     220                 :            : 
     221   [ +  +  +  +  :      24598 :         switch (op) {
          +  +  +  +  +  
                   +  + ]
     222                 :       1118 :             case MP_BINARY_OP_ADD:
     223                 :            :             case MP_BINARY_OP_INPLACE_ADD:
     224                 :       1118 :                 mpz_add_inpl(&res->mpz, zlhs, zrhs);
     225                 :       1118 :                 break;
     226                 :       1110 :             case MP_BINARY_OP_SUBTRACT:
     227                 :            :             case MP_BINARY_OP_INPLACE_SUBTRACT:
     228                 :       1110 :                 mpz_sub_inpl(&res->mpz, zlhs, zrhs);
     229                 :       1110 :                 break;
     230                 :       6366 :             case MP_BINARY_OP_MULTIPLY:
     231                 :            :             case MP_BINARY_OP_INPLACE_MULTIPLY:
     232                 :       6366 :                 mpz_mul_inpl(&res->mpz, zlhs, zrhs);
     233                 :       6366 :                 break;
     234                 :            :             case MP_BINARY_OP_FLOOR_DIVIDE:
     235                 :            :             case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: {
     236         [ +  + ]:       8928 :                 if (mpz_is_zero(zrhs)) {
     237                 :          4 :                 zero_division_error:
     238                 :         16 :                     mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero"));
     239                 :            :                 }
     240                 :       8924 :                 mpz_t rem;
     241                 :       8924 :                 mpz_init_zero(&rem);
     242                 :       8924 :                 mpz_divmod_inpl(&res->mpz, &rem, zlhs, zrhs);
     243                 :       8924 :                 mpz_deinit(&rem);
     244                 :       8924 :                 break;
     245                 :            :             }
     246                 :            :             case MP_BINARY_OP_MODULO:
     247                 :            :             case MP_BINARY_OP_INPLACE_MODULO: {
     248         [ +  + ]:        496 :                 if (mpz_is_zero(zrhs)) {
     249                 :          4 :                     goto zero_division_error;
     250                 :            :                 }
     251                 :        492 :                 mpz_t quo;
     252                 :        492 :                 mpz_init_zero(&quo);
     253                 :        492 :                 mpz_divmod_inpl(&quo, &res->mpz, zlhs, zrhs);
     254                 :        492 :                 mpz_deinit(&quo);
     255                 :        492 :                 break;
     256                 :            :             }
     257                 :            : 
     258                 :       1220 :             case MP_BINARY_OP_AND:
     259                 :            :             case MP_BINARY_OP_INPLACE_AND:
     260                 :       1220 :                 mpz_and_inpl(&res->mpz, zlhs, zrhs);
     261                 :       1220 :                 break;
     262                 :       1148 :             case MP_BINARY_OP_OR:
     263                 :            :             case MP_BINARY_OP_INPLACE_OR:
     264                 :       1148 :                 mpz_or_inpl(&res->mpz, zlhs, zrhs);
     265                 :       1148 :                 break;
     266                 :       1144 :             case MP_BINARY_OP_XOR:
     267                 :            :             case MP_BINARY_OP_INPLACE_XOR:
     268                 :       1144 :                 mpz_xor_inpl(&res->mpz, zlhs, zrhs);
     269                 :       1144 :                 break;
     270                 :            : 
     271                 :       2660 :             case MP_BINARY_OP_LSHIFT:
     272                 :            :             case MP_BINARY_OP_INPLACE_LSHIFT:
     273                 :            :             case MP_BINARY_OP_RSHIFT:
     274                 :            :             case MP_BINARY_OP_INPLACE_RSHIFT: {
     275                 :       2660 :                 mp_int_t irhs = mp_obj_int_get_checked(rhs_in);
     276         [ +  + ]:       2660 :                 if (irhs < 0) {
     277                 :          8 :                     mp_raise_ValueError(MP_ERROR_TEXT("negative shift count"));
     278                 :            :                 }
     279         [ +  + ]:       2652 :                 if (op == MP_BINARY_OP_LSHIFT || op == MP_BINARY_OP_INPLACE_LSHIFT) {
     280                 :       1352 :                     mpz_shl_inpl(&res->mpz, zlhs, irhs);
     281                 :            :                 } else {
     282                 :       1300 :                     mpz_shr_inpl(&res->mpz, zlhs, irhs);
     283                 :            :                 }
     284                 :            :                 break;
     285                 :            :             }
     286                 :            : 
     287                 :            :             case MP_BINARY_OP_POWER:
     288                 :            :             case MP_BINARY_OP_INPLACE_POWER:
     289         [ +  + ]:        388 :                 if (mpz_is_neg(zrhs)) {
     290                 :            :                     #if MICROPY_PY_BUILTINS_FLOAT
     291                 :          8 :                     return mp_obj_float_binary_op(op, mpz_as_float(zlhs), rhs_in);
     292                 :            :                     #else
     293                 :            :                     mp_raise_ValueError(MP_ERROR_TEXT("negative power with no float support"));
     294                 :            :                     #endif
     295                 :            :                 }
     296                 :        380 :                 mpz_pow_inpl(&res->mpz, zlhs, zrhs);
     297                 :        380 :                 break;
     298                 :            : 
     299                 :         20 :             default: {
     300         [ -  + ]:         20 :                 assert(op == MP_BINARY_OP_DIVMOD);
     301         [ +  + ]:         20 :                 if (mpz_is_zero(zrhs)) {
     302                 :          4 :                     goto zero_division_error;
     303                 :            :                 }
     304                 :         16 :                 mp_obj_int_t *quo = mp_obj_int_new_mpz();
     305                 :         16 :                 mpz_divmod_inpl(&quo->mpz, &res->mpz, zlhs, zrhs);
     306                 :         16 :                 mp_obj_t tuple[2] = {MP_OBJ_FROM_PTR(quo), MP_OBJ_FROM_PTR(res)};
     307                 :         16 :                 return mp_obj_new_tuple(2, tuple);
     308                 :            :             }
     309                 :            :         }
     310                 :            : 
     311                 :      24537 :         return MP_OBJ_FROM_PTR(res);
     312                 :            : 
     313                 :            :     } else {
     314                 :      18424 :         int cmp = mpz_cmp(zlhs, zrhs);
     315   [ +  +  +  +  :      18424 :         switch (op) {
                   +  + ]
     316                 :        186 :             case MP_BINARY_OP_LESS:
     317         [ +  + ]:        290 :                 return mp_obj_new_bool(cmp < 0);
     318                 :       7168 :             case MP_BINARY_OP_MORE:
     319         [ +  + ]:       7268 :                 return mp_obj_new_bool(cmp > 0);
     320                 :        160 :             case MP_BINARY_OP_LESS_EQUAL:
     321         [ +  + ]:        232 :                 return mp_obj_new_bool(cmp <= 0);
     322                 :        160 :             case MP_BINARY_OP_MORE_EQUAL:
     323         [ +  + ]:        232 :                 return mp_obj_new_bool(cmp >= 0);
     324                 :      10742 :             case MP_BINARY_OP_EQUAL:
     325         [ +  + ]:      20258 :                 return mp_obj_new_bool(cmp == 0);
     326                 :            : 
     327                 :            :             default:
     328                 :            :                 return MP_OBJ_NULL; // op not supported
     329                 :            :         }
     330                 :            :     }
     331                 :            : }
     332                 :            : 
     333                 :            : #if MICROPY_PY_BUILTINS_POW3
     334                 :        144 : STATIC mpz_t *mp_mpz_for_int(mp_obj_t arg, mpz_t *temp) {
     335         [ +  + ]:        144 :     if (mp_obj_is_small_int(arg)) {
     336                 :         96 :         mpz_init_from_int(temp, MP_OBJ_SMALL_INT_VALUE(arg));
     337                 :         96 :         return temp;
     338                 :            :     } else {
     339                 :         48 :         mp_obj_int_t *arp_p = MP_OBJ_TO_PTR(arg);
     340                 :         48 :         return &(arp_p->mpz);
     341                 :            :     }
     342                 :            : }
     343                 :            : 
     344                 :         60 : mp_obj_t mp_obj_int_pow3(mp_obj_t base, mp_obj_t exponent,  mp_obj_t modulus) {
     345   [ +  +  +  +  :         60 :     if (!mp_obj_is_int(base) || !mp_obj_is_int(exponent) || !mp_obj_is_int(modulus)) {
          +  -  +  +  +  
          +  +  -  +  +  
             +  +  -  + ]
     346                 :         12 :         mp_raise_TypeError(MP_ERROR_TEXT("pow() with 3 arguments requires integers"));
     347                 :            :     } else {
     348                 :         48 :         mp_obj_t result = mp_obj_new_int_from_ull(0); // Use the _from_ull version as this forces an mpz int
     349                 :         48 :         mp_obj_int_t *res_p = (mp_obj_int_t *)MP_OBJ_TO_PTR(result);
     350                 :            : 
     351                 :         48 :         mpz_t l_temp, r_temp, m_temp;
     352                 :         48 :         mpz_t *lhs = mp_mpz_for_int(base,     &l_temp);
     353                 :         48 :         mpz_t *rhs = mp_mpz_for_int(exponent, &r_temp);
     354                 :         48 :         mpz_t *mod = mp_mpz_for_int(modulus,  &m_temp);
     355                 :            : 
     356                 :         48 :         mpz_pow3_inpl(&(res_p->mpz), lhs, rhs, mod);
     357                 :            : 
     358         [ +  + ]:         48 :         if (lhs == &l_temp) {
     359                 :         36 :             mpz_deinit(lhs);
     360                 :            :         }
     361         [ +  + ]:         48 :         if (rhs == &r_temp) {
     362                 :         32 :             mpz_deinit(rhs);
     363                 :            :         }
     364         [ +  + ]:         48 :         if (mod == &m_temp) {
     365                 :         28 :             mpz_deinit(mod);
     366                 :            :         }
     367                 :         48 :         return result;
     368                 :            :     }
     369                 :            : }
     370                 :            : #endif
     371                 :            : 
     372                 :     121642 : mp_obj_t mp_obj_new_int(mp_int_t value) {
     373         [ +  + ]:     121642 :     if (MP_SMALL_INT_FITS(value)) {
     374                 :     121638 :         return MP_OBJ_NEW_SMALL_INT(value);
     375                 :            :     }
     376                 :          4 :     return mp_obj_new_int_from_ll(value);
     377                 :            : }
     378                 :            : 
     379                 :       1417 : mp_obj_t mp_obj_new_int_from_ll(long long val) {
     380                 :       1417 :     mp_obj_int_t *o = mp_obj_int_new_mpz();
     381                 :       1417 :     mpz_set_from_ll(&o->mpz, val, true);
     382                 :       1417 :     return MP_OBJ_FROM_PTR(o);
     383                 :            : }
     384                 :            : 
     385                 :        162 : mp_obj_t mp_obj_new_int_from_ull(unsigned long long val) {
     386                 :        162 :     mp_obj_int_t *o = mp_obj_int_new_mpz();
     387                 :        162 :     mpz_set_from_ll(&o->mpz, val, false);
     388                 :        162 :     return MP_OBJ_FROM_PTR(o);
     389                 :            : }
     390                 :            : 
     391                 :       1843 : mp_obj_t mp_obj_new_int_from_uint(mp_uint_t value) {
     392                 :            :     // SMALL_INT accepts only signed numbers, so make sure the input
     393                 :            :     // value fits completely in the small-int positive range.
     394         [ +  + ]:       1843 :     if ((value & ~MP_SMALL_INT_POSITIVE_MASK) == 0) {
     395                 :       1783 :         return MP_OBJ_NEW_SMALL_INT(value);
     396                 :            :     }
     397                 :         60 :     return mp_obj_new_int_from_ull(value);
     398                 :            : }
     399                 :            : 
     400                 :        903 : mp_obj_t mp_obj_new_int_from_str_len(const char **str, size_t len, bool neg, unsigned int base) {
     401                 :        903 :     mp_obj_int_t *o = mp_obj_int_new_mpz();
     402                 :        903 :     size_t n = mpz_set_from_str(&o->mpz, *str, len, neg, base);
     403                 :        903 :     *str += n;
     404                 :        903 :     return MP_OBJ_FROM_PTR(o);
     405                 :            : }
     406                 :            : 
     407                 :       1732 : mp_int_t mp_obj_int_get_truncated(mp_const_obj_t self_in) {
     408         [ +  + ]:       1732 :     if (mp_obj_is_small_int(self_in)) {
     409                 :       1728 :         return MP_OBJ_SMALL_INT_VALUE(self_in);
     410                 :            :     } else {
     411                 :          4 :         const mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in);
     412                 :            :         // hash returns actual int value if it fits in mp_int_t
     413                 :          4 :         return mpz_hash(&self->mpz);
     414                 :            :     }
     415                 :            : }
     416                 :            : 
     417                 :       2730 : mp_int_t mp_obj_int_get_checked(mp_const_obj_t self_in) {
     418         [ +  + ]:       2730 :     if (mp_obj_is_small_int(self_in)) {
     419                 :       2708 :         return MP_OBJ_SMALL_INT_VALUE(self_in);
     420                 :            :     } else {
     421                 :         22 :         const mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in);
     422                 :         22 :         mp_int_t value;
     423         [ +  + ]:         22 :         if (mpz_as_int_checked(&self->mpz, &value)) {
     424                 :         18 :             return value;
     425                 :            :         } else {
     426                 :            :             // overflow
     427                 :          4 :             mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("overflow converting long int to machine word"));
     428                 :            :         }
     429                 :            :     }
     430                 :            : }
     431                 :            : 
     432                 :          8 : mp_uint_t mp_obj_int_get_uint_checked(mp_const_obj_t self_in) {
     433         [ +  + ]:          8 :     if (mp_obj_is_small_int(self_in)) {
     434         [ +  + ]:          4 :         if (MP_OBJ_SMALL_INT_VALUE(self_in) >= 0) {
     435                 :          2 :             return MP_OBJ_SMALL_INT_VALUE(self_in);
     436                 :            :         }
     437                 :            :     } else {
     438                 :          4 :         const mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in);
     439                 :          4 :         mp_uint_t value;
     440         [ +  + ]:          4 :         if (mpz_as_uint_checked(&self->mpz, &value)) {
     441                 :          2 :             return value;
     442                 :            :         }
     443                 :            :     }
     444                 :            : 
     445                 :          4 :     mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("overflow converting long int to machine word"));
     446                 :            : }
     447                 :            : 
     448                 :            : #if MICROPY_PY_BUILTINS_FLOAT
     449                 :      21624 : mp_float_t mp_obj_int_as_float_impl(mp_obj_t self_in) {
     450   [ +  -  -  + ]:      21624 :     assert(mp_obj_is_exact_type(self_in, &mp_type_int));
     451                 :      21624 :     mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in);
     452                 :      21624 :     return mpz_as_float(&self->mpz);
     453                 :            : }
     454                 :            : #endif
     455                 :            : 
     456                 :            : #endif

Generated by: LCOV version 1.15-5-g462f71d