Damien George | 04b9147 | 2014-05-03 23:27:38 +0100 | [diff] [blame] | 1 | /* |
| 2 | * This file is part of the Micro Python project, http://micropython.org/ |
| 3 | * |
| 4 | * The MIT License (MIT) |
| 5 | * |
| 6 | * Copyright (c) 2013, 2014 Damien P. George |
Paul Sokolovsky | da9f092 | 2014-05-13 08:44:45 +0300 | [diff] [blame] | 7 | * Copyright (c) 2014 Paul Sokolovsky |
Damien George | 04b9147 | 2014-05-03 23:27:38 +0100 | [diff] [blame] | 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 | |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 28 | #include <stdlib.h> |
| 29 | #include <stdint.h> |
Dave Hylands | c4029e5 | 2014-04-07 11:19:51 -0700 | [diff] [blame] | 30 | #include <string.h> |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 31 | |
Paul Sokolovsky | f54bcbf | 2014-05-02 17:47:01 +0300 | [diff] [blame] | 32 | #include "mpconfig.h" |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 33 | #include "nlr.h" |
| 34 | #include "misc.h" |
Damien George | 55baff4 | 2014-01-21 21:40:13 +0000 | [diff] [blame] | 35 | #include "qstr.h" |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 36 | #include "obj.h" |
Damien George | d1e355e | 2014-05-28 14:51:12 +0100 | [diff] [blame] | 37 | #include "smallint.h" |
Damien George | 438c88d | 2014-02-22 19:25:23 +0000 | [diff] [blame] | 38 | #include "mpz.h" |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 39 | #include "objint.h" |
| 40 | #include "runtime0.h" |
Damien George | 660aef6 | 2014-04-02 12:22:07 +0100 | [diff] [blame] | 41 | #include "runtime.h" |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 42 | |
| 43 | #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG |
| 44 | |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 45 | // Python3 no longer has "l" suffix for long ints. We allow to use it |
| 46 | // for debugging purpose though. |
| 47 | #ifdef DEBUG |
| 48 | #define SUFFIX "l" |
| 49 | #else |
| 50 | #define SUFFIX "" |
| 51 | #endif |
| 52 | |
Damien George | 88d7bba | 2014-04-08 23:30:46 +0100 | [diff] [blame] | 53 | bool mp_obj_int_is_positive(mp_obj_t self_in) { |
| 54 | if (MP_OBJ_IS_SMALL_INT(self_in)) { |
| 55 | return MP_OBJ_SMALL_INT_VALUE(self_in) >= 0; |
| 56 | } |
| 57 | mp_obj_int_t *self = self_in; |
| 58 | return self->val >= 0; |
| 59 | } |
| 60 | |
Damien George | e8208a7 | 2014-04-04 15:08:23 +0100 | [diff] [blame] | 61 | mp_obj_t mp_obj_int_unary_op(int op, mp_obj_t o_in) { |
Paul Sokolovsky | 9b00dad | 2014-01-27 09:05:50 +0200 | [diff] [blame] | 62 | mp_obj_int_t *o = o_in; |
| 63 | switch (op) { |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 64 | case MP_UNARY_OP_BOOL: return MP_BOOL(o->val != 0); |
| 65 | case MP_UNARY_OP_POSITIVE: return o_in; |
| 66 | case MP_UNARY_OP_NEGATIVE: return mp_obj_new_int_from_ll(-o->val); |
| 67 | case MP_UNARY_OP_INVERT: return mp_obj_new_int_from_ll(~o->val); |
Damien George | 6ac5dce | 2014-05-21 19:42:43 +0100 | [diff] [blame] | 68 | default: return MP_OBJ_NULL; // op not supported |
Paul Sokolovsky | 9b00dad | 2014-01-27 09:05:50 +0200 | [diff] [blame] | 69 | } |
| 70 | } |
| 71 | |
Damien George | e8208a7 | 2014-04-04 15:08:23 +0100 | [diff] [blame] | 72 | mp_obj_t mp_obj_int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) { |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 73 | long long lhs_val; |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 74 | long long rhs_val; |
| 75 | |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 76 | if (MP_OBJ_IS_SMALL_INT(lhs_in)) { |
| 77 | lhs_val = MP_OBJ_SMALL_INT_VALUE(lhs_in); |
Damien George | 3e1a5c1 | 2014-03-29 13:43:38 +0000 | [diff] [blame] | 78 | } else if (MP_OBJ_IS_TYPE(lhs_in, &mp_type_int)) { |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 79 | lhs_val = ((mp_obj_int_t*)lhs_in)->val; |
| 80 | } else { |
Damien George | 6ac5dce | 2014-05-21 19:42:43 +0100 | [diff] [blame] | 81 | return MP_OBJ_NULL; // op not supported |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 82 | } |
Damien George | c412998 | 2014-03-19 23:17:23 +0000 | [diff] [blame] | 83 | |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 84 | if (MP_OBJ_IS_SMALL_INT(rhs_in)) { |
| 85 | rhs_val = MP_OBJ_SMALL_INT_VALUE(rhs_in); |
Damien George | 3e1a5c1 | 2014-03-29 13:43:38 +0000 | [diff] [blame] | 86 | } else if (MP_OBJ_IS_TYPE(rhs_in, &mp_type_int)) { |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 87 | rhs_val = ((mp_obj_int_t*)rhs_in)->val; |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 88 | } else { |
Damien George | e8208a7 | 2014-04-04 15:08:23 +0100 | [diff] [blame] | 89 | // delegate to generic function to check for extra cases |
| 90 | return mp_obj_int_binary_op_extra_cases(op, lhs_in, rhs_in); |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 91 | } |
| 92 | |
| 93 | switch (op) { |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 94 | case MP_BINARY_OP_ADD: |
| 95 | case MP_BINARY_OP_INPLACE_ADD: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 96 | return mp_obj_new_int_from_ll(lhs_val + rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 97 | case MP_BINARY_OP_SUBTRACT: |
| 98 | case MP_BINARY_OP_INPLACE_SUBTRACT: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 99 | return mp_obj_new_int_from_ll(lhs_val - rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 100 | case MP_BINARY_OP_MULTIPLY: |
| 101 | case MP_BINARY_OP_INPLACE_MULTIPLY: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 102 | return mp_obj_new_int_from_ll(lhs_val * rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 103 | case MP_BINARY_OP_FLOOR_DIVIDE: |
| 104 | case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 105 | return mp_obj_new_int_from_ll(lhs_val / rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 106 | case MP_BINARY_OP_MODULO: |
| 107 | case MP_BINARY_OP_INPLACE_MODULO: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 108 | return mp_obj_new_int_from_ll(lhs_val % rhs_val); |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 109 | |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 110 | case MP_BINARY_OP_AND: |
| 111 | case MP_BINARY_OP_INPLACE_AND: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 112 | return mp_obj_new_int_from_ll(lhs_val & rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 113 | case MP_BINARY_OP_OR: |
| 114 | case MP_BINARY_OP_INPLACE_OR: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 115 | return mp_obj_new_int_from_ll(lhs_val | rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 116 | case MP_BINARY_OP_XOR: |
| 117 | case MP_BINARY_OP_INPLACE_XOR: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 118 | return mp_obj_new_int_from_ll(lhs_val ^ rhs_val); |
Paul Sokolovsky | 9b00dad | 2014-01-27 09:05:50 +0200 | [diff] [blame] | 119 | |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 120 | case MP_BINARY_OP_LSHIFT: |
| 121 | case MP_BINARY_OP_INPLACE_LSHIFT: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 122 | return mp_obj_new_int_from_ll(lhs_val << (int)rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 123 | case MP_BINARY_OP_RSHIFT: |
| 124 | case MP_BINARY_OP_INPLACE_RSHIFT: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 125 | return mp_obj_new_int_from_ll(lhs_val >> (int)rhs_val); |
Paul Sokolovsky | 9b00dad | 2014-01-27 09:05:50 +0200 | [diff] [blame] | 126 | |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 127 | case MP_BINARY_OP_LESS: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 128 | return MP_BOOL(lhs_val < rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 129 | case MP_BINARY_OP_MORE: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 130 | return MP_BOOL(lhs_val > rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 131 | case MP_BINARY_OP_LESS_EQUAL: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 132 | return MP_BOOL(lhs_val <= rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 133 | case MP_BINARY_OP_MORE_EQUAL: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 134 | return MP_BOOL(lhs_val >= rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 135 | case MP_BINARY_OP_EQUAL: |
Damien George | d02f6ea | 2014-03-20 19:31:32 +0000 | [diff] [blame] | 136 | return MP_BOOL(lhs_val == rhs_val); |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 137 | |
| 138 | default: |
Damien George | 6ac5dce | 2014-05-21 19:42:43 +0100 | [diff] [blame] | 139 | return MP_OBJ_NULL; // op not supported |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 140 | } |
| 141 | } |
| 142 | |
| 143 | mp_obj_t mp_obj_new_int(machine_int_t value) { |
Damien George | d1e355e | 2014-05-28 14:51:12 +0100 | [diff] [blame] | 144 | if (MP_SMALL_INT_FITS(value)) { |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 145 | return MP_OBJ_NEW_SMALL_INT(value); |
| 146 | } |
| 147 | return mp_obj_new_int_from_ll(value); |
| 148 | } |
| 149 | |
| 150 | mp_obj_t mp_obj_new_int_from_uint(machine_uint_t value) { |
| 151 | // SMALL_INT accepts only signed numbers, of one bit less size |
| 152 | // than word size, which totals 2 bits less for unsigned numbers. |
| 153 | if ((value & (WORD_MSBIT_HIGH | (WORD_MSBIT_HIGH >> 1))) == 0) { |
| 154 | return MP_OBJ_NEW_SMALL_INT(value); |
| 155 | } |
| 156 | return mp_obj_new_int_from_ll(value); |
| 157 | } |
| 158 | |
| 159 | mp_obj_t mp_obj_new_int_from_ll(long long val) { |
| 160 | mp_obj_int_t *o = m_new_obj(mp_obj_int_t); |
Damien George | 3e1a5c1 | 2014-03-29 13:43:38 +0000 | [diff] [blame] | 161 | o->base.type = &mp_type_int; |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 162 | o->val = val; |
| 163 | return o; |
| 164 | } |
| 165 | |
Damien George | 503d611 | 2014-05-28 14:07:21 +0100 | [diff] [blame] | 166 | mp_obj_t mp_obj_new_int_from_str_len(const char **str, uint len, bool neg, uint base) { |
| 167 | // TODO this does not honor the given length of the string, but it all cases it should anyway be null terminated |
| 168 | // TODO check overflow |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 169 | mp_obj_int_t *o = m_new_obj(mp_obj_int_t); |
Damien George | 3e1a5c1 | 2014-03-29 13:43:38 +0000 | [diff] [blame] | 170 | o->base.type = &mp_type_int; |
Damien George | 503d611 | 2014-05-28 14:07:21 +0100 | [diff] [blame] | 171 | char *endptr; |
| 172 | o->val = strtoll(*str, &endptr, base); |
| 173 | *str = endptr; |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 174 | return o; |
| 175 | } |
| 176 | |
Damien George | 503d611 | 2014-05-28 14:07:21 +0100 | [diff] [blame] | 177 | machine_int_t mp_obj_int_get(mp_const_obj_t self_in) { |
Paul Sokolovsky | d26b379 | 2014-01-18 16:07:16 +0200 | [diff] [blame] | 178 | if (MP_OBJ_IS_SMALL_INT(self_in)) { |
| 179 | return MP_OBJ_SMALL_INT_VALUE(self_in); |
Damien George | eabdf67 | 2014-03-22 20:54:01 +0000 | [diff] [blame] | 180 | } else { |
Damien George | 503d611 | 2014-05-28 14:07:21 +0100 | [diff] [blame] | 181 | const mp_obj_int_t *self = self_in; |
Damien George | eabdf67 | 2014-03-22 20:54:01 +0000 | [diff] [blame] | 182 | return self->val; |
Paul Sokolovsky | d26b379 | 2014-01-18 16:07:16 +0200 | [diff] [blame] | 183 | } |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 184 | } |
| 185 | |
Paul Sokolovsky | ab7bf28 | 2014-05-17 11:08:33 +0300 | [diff] [blame] | 186 | machine_int_t mp_obj_int_get_checked(mp_const_obj_t self_in) { |
Paul Sokolovsky | d26b379 | 2014-01-18 16:07:16 +0200 | [diff] [blame] | 187 | // TODO: Check overflow |
| 188 | return mp_obj_int_get(self_in); |
| 189 | } |
| 190 | |
Damien George | fb510b3 | 2014-06-01 13:32:54 +0100 | [diff] [blame^] | 191 | #if MICROPY_PY_BUILTINS_FLOAT |
Damien George | eabdf67 | 2014-03-22 20:54:01 +0000 | [diff] [blame] | 192 | mp_float_t mp_obj_int_as_float(mp_obj_t self_in) { |
| 193 | if (MP_OBJ_IS_SMALL_INT(self_in)) { |
| 194 | return MP_OBJ_SMALL_INT_VALUE(self_in); |
| 195 | } else { |
| 196 | mp_obj_int_t *self = self_in; |
| 197 | return self->val; |
| 198 | } |
| 199 | } |
| 200 | #endif |
| 201 | |
Paul Sokolovsky | 966879c | 2014-01-17 20:01:36 +0200 | [diff] [blame] | 202 | #endif |