blob: 26e1cc048f6effa8128fb705a3f4ff4a7dabfffb [file] [log] [blame]
Damien George04b91472014-05-03 23:27:38 +01001/*
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
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
Damien George660aef62014-04-02 12:22:07 +010027#include <stdlib.h>
Damien George45b43c22014-01-05 01:50:45 +000028#include <assert.h>
Dave Hylandsc4029e52014-04-07 11:19:51 -070029#include <string.h>
Damien George45b43c22014-01-05 01:50:45 +000030
Damien George51dfcb42015-01-01 20:27:54 +000031#include "py/nlr.h"
32#include "py/parsenum.h"
33#include "py/smallint.h"
34#include "py/objint.h"
35#include "py/objstr.h"
36#include "py/runtime0.h"
37#include "py/runtime.h"
Paul Sokolovsky48b35722014-01-12 17:30:48 +020038
Damien Georgefb510b32014-06-01 13:32:54 +010039#if MICROPY_PY_BUILTINS_FLOAT
Damien George6433bd92014-03-30 23:13:16 +010040#include <math.h>
41#endif
42
Damien Georgee8208a72014-04-04 15:08:23 +010043// This dispatcher function is expected to be independent of the implementation of long int
Damien Georgeecc88e92014-08-30 00:35:11 +010044STATIC mp_obj_t mp_obj_int_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
Damien Georgeff8dd3f2015-01-20 12:47:20 +000045 (void)type_in;
Damien Georgeee7a8802014-05-11 18:37:21 +010046 mp_arg_check_num(n_args, n_kw, 0, 2, false);
Damien George20006db2014-01-18 14:10:48 +000047
Damien George45b43c22014-01-05 01:50:45 +000048 switch (n_args) {
49 case 0:
50 return MP_OBJ_NEW_SMALL_INT(0);
51
52 case 1:
Damien George813ed3b2014-05-28 14:09:46 +010053 if (MP_OBJ_IS_INT(args[0])) {
54 // already an int (small or long), just return it
55 return args[0];
Dave Hylandsb7f7c652014-08-26 12:44:46 -070056 } else if (MP_OBJ_IS_STR_OR_BYTES(args[0])) {
Damien George5573f9f2014-01-15 22:58:39 +000057 // a string, parse it
Damien Georged182b982014-08-30 14:19:41 +010058 mp_uint_t l;
Damien George698ec212014-02-08 18:17:23 +000059 const char *s = mp_obj_str_get_data(args[0], &l);
Damien George7d414a12015-02-08 01:57:40 +000060 return mp_parse_num_integer(s, l, 0, NULL);
Damien Georgefb510b32014-06-01 13:32:54 +010061#if MICROPY_PY_BUILTINS_FLOAT
Damien George6433bd92014-03-30 23:13:16 +010062 } else if (MP_OBJ_IS_TYPE(args[0], &mp_type_float)) {
Paul Sokolovsky12033df2014-12-30 00:22:10 +020063 return mp_obj_new_int_from_float(mp_obj_float_get(args[0]));
Damien George6433bd92014-03-30 23:13:16 +010064#endif
Damien George5573f9f2014-01-15 22:58:39 +000065 } else {
Damien George813ed3b2014-05-28 14:09:46 +010066 // try to convert to small int (eg from bool)
Damien George5573f9f2014-01-15 22:58:39 +000067 return MP_OBJ_NEW_SMALL_INT(mp_obj_get_int(args[0]));
68 }
Damien George45b43c22014-01-05 01:50:45 +000069
xybc178ea42014-01-14 21:39:05 +080070 case 2:
Damien Georgeee7a8802014-05-11 18:37:21 +010071 default: {
Damien George5573f9f2014-01-15 22:58:39 +000072 // should be a string, parse it
73 // TODO proper error checking of argument types
Damien Georged182b982014-08-30 14:19:41 +010074 mp_uint_t l;
Damien George698ec212014-02-08 18:17:23 +000075 const char *s = mp_obj_str_get_data(args[0], &l);
Damien George7d414a12015-02-08 01:57:40 +000076 return mp_parse_num_integer(s, l, mp_obj_get_int(args[1]), NULL);
Damien George5fa93b62014-01-22 14:35:10 +000077 }
Damien George45b43c22014-01-05 01:50:45 +000078 }
79}
80
David Steinbergca377b12015-01-13 15:21:17 +000081#if MICROPY_PY_BUILTINS_FLOAT
82mp_fp_as_int_class_t mp_classify_fp_as_int(mp_float_t val) {
83 union {
84 mp_float_t f;
85#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
86 uint32_t i;
87#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
88 uint32_t i[2];
89#endif
90 } u = {val};
91
92 uint32_t e;
93#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
94 e = u.i;
95#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
96 e = u.i[MP_ENDIANNESS_LITTLE];
97#endif
98#define MP_FLOAT_SIGN_SHIFT_I32 ((MP_FLOAT_FRAC_BITS + MP_FLOAT_EXP_BITS) % 32)
99#define MP_FLOAT_EXP_SHIFT_I32 (MP_FLOAT_FRAC_BITS % 32)
100
101 if (e & (1 << MP_FLOAT_SIGN_SHIFT_I32)) {
102#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
103 e |= u.i[MP_ENDIANNESS_BIG] != 0;
104#endif
105 e += ((1 << MP_FLOAT_EXP_BITS) - 1) << MP_FLOAT_EXP_SHIFT_I32;
106 } else {
107 e &= ~((1 << MP_FLOAT_EXP_SHIFT_I32) - 1);
108 }
109 if (e <= ((BITS_PER_WORD + MP_FLOAT_EXP_BIAS - 3) << MP_FLOAT_EXP_SHIFT_I32)) {
110 return MP_FP_CLASS_FIT_SMALLINT;
111 }
112#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG
113 if (e <= (((sizeof(long long) * BITS_PER_BYTE) + MP_FLOAT_EXP_BIAS - 2) << MP_FLOAT_EXP_SHIFT_I32)) {
114 return MP_FP_CLASS_FIT_LONGINT;
115 }
116#endif
117#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_MPZ
118 return MP_FP_CLASS_FIT_LONGINT;
119#else
120 return MP_FP_CLASS_OVERFLOW;
121#endif
122}
123#undef MP_FLOAT_SIGN_SHIFT_I32
124#undef MP_FLOAT_EXP_SHIFT_I32
125#endif
126
Damien Georgee8208a72014-04-04 15:08:23 +0100127void mp_obj_int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
Damien Georgeff8dd3f2015-01-20 12:47:20 +0000128 (void)kind;
Dave Hylandsc4029e52014-04-07 11:19:51 -0700129 // The size of this buffer is rather arbitrary. If it's not large
130 // enough, a dynamic one will be allocated.
Damien George40f3c022014-07-03 13:25:24 +0100131 char stack_buf[sizeof(mp_int_t) * 4];
Dave Hylandsc4029e52014-04-07 11:19:51 -0700132 char *buf = stack_buf;
Damien George42f3de92014-10-03 17:44:14 +0000133 mp_uint_t buf_size = sizeof(stack_buf);
134 mp_uint_t fmt_size;
Dave Hylandsc4029e52014-04-07 11:19:51 -0700135
136 char *str = mp_obj_int_formatted(&buf, &buf_size, &fmt_size, self_in, 10, NULL, '\0', '\0');
137 print(env, "%s", str);
138
139 if (buf != stack_buf) {
Damien George4d77e1a2015-02-27 09:34:51 +0000140 m_del(char, buf, buf_size);
Damien George5fa93b62014-01-22 14:35:10 +0000141 }
Damien George45b43c22014-01-05 01:50:45 +0000142}
Paul Sokolovsky48b35722014-01-12 17:30:48 +0200143
Dave Hylandsc4029e52014-04-07 11:19:51 -0700144#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG
Damien George88d7bba2014-04-08 23:30:46 +0100145typedef mp_longint_impl_t fmt_int_t;
Dave Hylandsc4029e52014-04-07 11:19:51 -0700146#else
Damien George40f3c022014-07-03 13:25:24 +0100147typedef mp_int_t fmt_int_t;
Dave Hylandsc4029e52014-04-07 11:19:51 -0700148#endif
149
Damien George1c70cbf2014-08-30 00:38:16 +0100150STATIC const uint8_t log_base2_floor[] = {
Dave Hylandsc4029e52014-04-07 11:19:51 -0700151 0,
152 0, 1, 1, 2,
153 2, 2, 2, 3,
154 3, 3, 3, 3,
155 3, 3, 3, 4,
156 4, 4, 4, 4,
157 4, 4, 4, 4,
158 4, 4, 4, 4,
159 4, 4, 4, 5
160};
161
Damien George88d7bba2014-04-08 23:30:46 +0100162STATIC uint int_as_str_size_formatted(uint base, const char *prefix, char comma) {
Dave Hylandsc4029e52014-04-07 11:19:51 -0700163 if (base < 2 || base > 32) {
164 return 0;
165 }
166
167 uint num_digits = sizeof(fmt_int_t) * 8 / log_base2_floor[base] + 1;
168 uint num_commas = comma ? num_digits / 3: 0;
169 uint prefix_len = prefix ? strlen(prefix) : 0;
170 return num_digits + num_commas + prefix_len + 2; // +1 for sign, +1 for null byte
171}
172
Paul Sokolovskyd72bc272014-06-06 23:08:37 +0300173// This routine expects you to pass in a buffer and size (in *buf and *buf_size).
Dave Hylandsc4029e52014-04-07 11:19:51 -0700174// If, for some reason, this buffer is too small, then it will allocate a
175// buffer and return the allocated buffer and size in *buf and *buf_size. It
176// is the callers responsibility to free this allocated buffer.
177//
178// The resulting formatted string will be returned from this function and the
179// formatted size will be in *fmt_size.
Damien George42f3de92014-10-03 17:44:14 +0000180char *mp_obj_int_formatted(char **buf, mp_uint_t *buf_size, mp_uint_t *fmt_size, mp_const_obj_t self_in,
Dave Hylandsc4029e52014-04-07 11:19:51 -0700181 int base, const char *prefix, char base_char, char comma) {
Damien George88d7bba2014-04-08 23:30:46 +0100182 fmt_int_t num;
183 if (MP_OBJ_IS_SMALL_INT(self_in)) {
184 // A small int; get the integer value to format.
185 num = mp_obj_get_int(self_in);
186#if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
187 } else if (MP_OBJ_IS_TYPE(self_in, &mp_type_int)) {
188 // Not a small int.
189#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG
Damien George503d6112014-05-28 14:07:21 +0100190 const mp_obj_int_t *self = self_in;
Damien George40f3c022014-07-03 13:25:24 +0100191 // Get the value to format; mp_obj_get_int truncates to mp_int_t.
Damien George88d7bba2014-04-08 23:30:46 +0100192 num = self->val;
193#else
194 // Delegate to the implementation for the long int.
195 return mp_obj_int_formatted_impl(buf, buf_size, fmt_size, self_in, base, prefix, base_char, comma);
196#endif
197#endif
198 } else {
199 // Not an int.
Paul Sokolovskyd72bc272014-06-06 23:08:37 +0300200 **buf = '\0';
Dave Hylandsc4029e52014-04-07 11:19:51 -0700201 *fmt_size = 0;
202 return *buf;
203 }
Damien George88d7bba2014-04-08 23:30:46 +0100204
Dave Hylandsc4029e52014-04-07 11:19:51 -0700205 char sign = '\0';
206 if (num < 0) {
207 num = -num;
208 sign = '-';
209 }
210
211 uint needed_size = int_as_str_size_formatted(base, prefix, comma);
212 if (needed_size > *buf_size) {
213 *buf = m_new(char, needed_size);
214 *buf_size = needed_size;
215 }
216 char *str = *buf;
217
218 char *b = str + needed_size;
219 *(--b) = '\0';
220 char *last_comma = b;
221
222 if (num == 0) {
223 *(--b) = '0';
224 } else {
225 do {
226 int c = num % base;
227 num /= base;
228 if (c >= 10) {
229 c += base_char - 10;
230 } else {
231 c += '0';
232 }
233 *(--b) = c;
234 if (comma && num != 0 && b > str && (last_comma - b) == 3) {
235 *(--b) = comma;
236 last_comma = b;
237 }
238 }
239 while (b > str && num != 0);
240 }
241 if (prefix) {
242 size_t prefix_len = strlen(prefix);
243 char *p = b - prefix_len;
244 if (p > str) {
245 b = p;
246 while (*prefix) {
247 *p++ = *prefix++;
248 }
249 }
250 }
251 if (sign && b > str) {
252 *(--b) = sign;
253 }
254 *fmt_size = *buf + needed_size - b - 1;
255
256 return b;
257}
258
Damien George88d7bba2014-04-08 23:30:46 +0100259#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_NONE
260
Damien Georgeffe911d2014-07-24 14:21:37 +0100261mp_int_t mp_obj_int_hash(mp_obj_t self_in) {
262 return MP_OBJ_SMALL_INT_VALUE(self_in);
263}
264
Dave Hylandsc4029e52014-04-07 11:19:51 -0700265bool mp_obj_int_is_positive(mp_obj_t self_in) {
266 return mp_obj_get_int(self_in) >= 0;
267}
Dave Hylandsc4029e52014-04-07 11:19:51 -0700268
Damien George6837d462015-03-14 22:07:30 +0000269// This must handle int and bool types, and must raise a
270// TypeError if the argument is not integral
271mp_obj_t mp_obj_int_abs(mp_obj_t self_in) {
272 mp_int_t val = mp_obj_get_int(self_in);
273 if (val < 0) {
274 val = -val;
275 }
276 return MP_OBJ_NEW_SMALL_INT(val);
277}
278
Damien George660aef62014-04-02 12:22:07 +0100279// This is called for operations on SMALL_INT that are not handled by mp_unary_op
Damien Georgeecc88e92014-08-30 00:35:11 +0100280mp_obj_t mp_obj_int_unary_op(mp_uint_t op, mp_obj_t o_in) {
Damien George6ac5dce2014-05-21 19:42:43 +0100281 return MP_OBJ_NULL; // op not supported
Paul Sokolovsky9b00dad2014-01-27 09:05:50 +0200282}
283
Damien George660aef62014-04-02 12:22:07 +0100284// This is called for operations on SMALL_INT that are not handled by mp_binary_op
Damien Georgeecc88e92014-08-30 00:35:11 +0100285mp_obj_t mp_obj_int_binary_op(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
Damien Georgee8208a72014-04-04 15:08:23 +0100286 return mp_obj_int_binary_op_extra_cases(op, lhs_in, rhs_in);
Paul Sokolovsky48b35722014-01-12 17:30:48 +0200287}
288
289// This is called only with strings whose value doesn't fit in SMALL_INT
Damien George4abff752014-08-30 14:59:21 +0100290mp_obj_t mp_obj_new_int_from_str_len(const char **str, mp_uint_t len, bool neg, mp_uint_t base) {
Damien Georgeea13f402014-04-05 18:32:08 +0100291 nlr_raise(mp_obj_new_exception_msg(&mp_type_OverflowError, "long int not supported in this build"));
Damien George23005372014-01-13 19:39:01 +0000292 return mp_const_none;
Paul Sokolovsky48b35722014-01-12 17:30:48 +0200293}
294
Damien George9d68e9c2014-03-12 15:38:15 +0000295// This is called when an integer larger than a SMALL_INT is needed (although val might still fit in a SMALL_INT)
296mp_obj_t mp_obj_new_int_from_ll(long long val) {
Damien Georgeea13f402014-04-05 18:32:08 +0100297 nlr_raise(mp_obj_new_exception_msg(&mp_type_OverflowError, "small int overflow"));
Damien George9d68e9c2014-03-12 15:38:15 +0000298 return mp_const_none;
299}
300
Damien George95307432014-09-10 22:10:33 +0100301// This is called when an integer larger than a SMALL_INT is needed (although val might still fit in a SMALL_INT)
302mp_obj_t mp_obj_new_int_from_ull(unsigned long long val) {
303 nlr_raise(mp_obj_new_exception_msg(&mp_type_OverflowError, "small int overflow"));
304 return mp_const_none;
305}
306
Damien George40f3c022014-07-03 13:25:24 +0100307mp_obj_t mp_obj_new_int_from_uint(mp_uint_t value) {
Paul Sokolovsky48b35722014-01-12 17:30:48 +0200308 // SMALL_INT accepts only signed numbers, of one bit less size
309 // then word size, which totals 2 bits less for unsigned numbers.
310 if ((value & (WORD_MSBIT_HIGH | (WORD_MSBIT_HIGH >> 1))) == 0) {
311 return MP_OBJ_NEW_SMALL_INT(value);
312 }
Damien Georgeea13f402014-04-05 18:32:08 +0100313 nlr_raise(mp_obj_new_exception_msg(&mp_type_OverflowError, "small int overflow"));
Damien George23005372014-01-13 19:39:01 +0000314 return mp_const_none;
Paul Sokolovsky48b35722014-01-12 17:30:48 +0200315}
316
Paul Sokolovskyf79cd6a2014-12-30 00:33:32 +0200317#if MICROPY_PY_BUILTINS_FLOAT
318mp_obj_t mp_obj_new_int_from_float(mp_float_t val) {
David Steinberg0fb17f62015-01-13 15:22:30 +0000319 int cl = fpclassify(val);
320 if (cl == FP_INFINITE) {
321 nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OverflowError, "can't convert inf to int"));
322 } else if (cl == FP_NAN) {
323 nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "can't convert NaN to int"));
324 } else {
325 mp_fp_as_int_class_t icl = mp_classify_fp_as_int(val);
326 if (icl == MP_FP_CLASS_FIT_SMALLINT) {
327 return MP_OBJ_NEW_SMALL_INT((mp_int_t)val);
328 } else {
329 nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "float too big"));
330 }
331 }
Paul Sokolovskyf79cd6a2014-12-30 00:33:32 +0200332}
333#endif
334
Damien George40f3c022014-07-03 13:25:24 +0100335mp_obj_t mp_obj_new_int(mp_int_t value) {
Damien Georged1e355e2014-05-28 14:51:12 +0100336 if (MP_SMALL_INT_FITS(value)) {
Paul Sokolovsky48b35722014-01-12 17:30:48 +0200337 return MP_OBJ_NEW_SMALL_INT(value);
338 }
Damien Georgeea13f402014-04-05 18:32:08 +0100339 nlr_raise(mp_obj_new_exception_msg(&mp_type_OverflowError, "small int overflow"));
Damien George23005372014-01-13 19:39:01 +0000340 return mp_const_none;
Paul Sokolovsky48b35722014-01-12 17:30:48 +0200341}
Paul Sokolovskyd26b3792014-01-18 16:07:16 +0200342
Damien Georgebe6d8be2014-12-05 23:13:52 +0000343mp_int_t mp_obj_int_get_truncated(mp_const_obj_t self_in) {
Paul Sokolovskyd26b3792014-01-18 16:07:16 +0200344 return MP_OBJ_SMALL_INT_VALUE(self_in);
345}
346
Damien George40f3c022014-07-03 13:25:24 +0100347mp_int_t mp_obj_int_get_checked(mp_const_obj_t self_in) {
Paul Sokolovskyd26b3792014-01-18 16:07:16 +0200348 return MP_OBJ_SMALL_INT_VALUE(self_in);
349}
350
Damien Georgefb510b32014-06-01 13:32:54 +0100351#if MICROPY_PY_BUILTINS_FLOAT
Damien Georgeeabdf672014-03-22 20:54:01 +0000352mp_float_t mp_obj_int_as_float(mp_obj_t self_in) {
353 return MP_OBJ_SMALL_INT_VALUE(self_in);
354}
355#endif
356
Damien George5fa93b62014-01-22 14:35:10 +0000357#endif // MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_NONE
358
Damien Georgee8208a72014-04-04 15:08:23 +0100359// This dispatcher function is expected to be independent of the implementation of long int
360// It handles the extra cases for integer-like arithmetic
Damien Georgeecc88e92014-08-30 00:35:11 +0100361mp_obj_t mp_obj_int_binary_op_extra_cases(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
Damien Georgee8208a72014-04-04 15:08:23 +0100362 if (rhs_in == mp_const_false) {
363 // false acts as 0
364 return mp_binary_op(op, lhs_in, MP_OBJ_NEW_SMALL_INT(0));
365 } else if (rhs_in == mp_const_true) {
366 // true acts as 0
367 return mp_binary_op(op, lhs_in, MP_OBJ_NEW_SMALL_INT(1));
368 } else if (op == MP_BINARY_OP_MULTIPLY) {
Damien George9b7a8ee2014-08-13 13:22:24 +0100369 if (MP_OBJ_IS_STR(rhs_in) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_bytes) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_list)) {
Damien Georgee8208a72014-04-04 15:08:23 +0100370 // multiply is commutative for these types, so delegate to them
371 return mp_binary_op(op, rhs_in, lhs_in);
372 }
373 }
Damien George6ac5dce2014-05-21 19:42:43 +0100374 return MP_OBJ_NULL; // op not supported
Damien Georgee8208a72014-04-04 15:08:23 +0100375}
376
Damien George5213eb32014-04-13 12:24:13 +0100377// this is a classmethod
Damien Georgeecc88e92014-08-30 00:35:11 +0100378STATIC mp_obj_t int_from_bytes(mp_uint_t n_args, const mp_obj_t *args) {
Paul Sokolovskya985b452014-04-09 00:40:58 +0300379 // TODO: Support long ints
Damien George5213eb32014-04-13 12:24:13 +0100380 // TODO: Support byteorder param (assumes 'little' at the moment)
381 // TODO: Support signed param (assumes signed=False at the moment)
Damien Georgeff8dd3f2015-01-20 12:47:20 +0000382 (void)n_args;
Damien George5213eb32014-04-13 12:24:13 +0100383
384 // get the buffer info
Damien George57a4b4f2014-04-18 22:29:21 +0100385 mp_buffer_info_t bufinfo;
Damien Georgeb11b85a2014-04-18 22:59:24 +0100386 mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
Damien George5213eb32014-04-13 12:24:13 +0100387
388 // convert the bytes to an integer
Damien George40f3c022014-07-03 13:25:24 +0100389 mp_uint_t value = 0;
stijn01d6be42014-05-05 12:18:27 +0200390 for (const byte* buf = (const byte*)bufinfo.buf + bufinfo.len - 1; buf >= (byte*)bufinfo.buf; buf--) {
Damien Georgeb9e7ed42014-04-13 12:40:50 +0100391 value = (value << 8) | *buf;
Damien George5213eb32014-04-13 12:24:13 +0100392 }
393
394 return mp_obj_new_int_from_uint(value);
Paul Sokolovskya985b452014-04-09 00:40:58 +0300395}
396
Damien George5213eb32014-04-13 12:24:13 +0100397STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(int_from_bytes_fun_obj, 2, 3, int_from_bytes);
398STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(int_from_bytes_obj, (const mp_obj_t)&int_from_bytes_fun_obj);
Paul Sokolovskya985b452014-04-09 00:40:58 +0300399
Damien Georgeecc88e92014-08-30 00:35:11 +0100400STATIC mp_obj_t int_to_bytes(mp_uint_t n_args, const mp_obj_t *args) {
Paul Sokolovskya985b452014-04-09 00:40:58 +0300401 // TODO: Support long ints
Damien Georgefcdb2392014-10-06 13:45:34 +0000402 // TODO: Support byteorder param (assumes 'little')
403 // TODO: Support signed param (assumes signed=False)
Damien Georgeff8dd3f2015-01-20 12:47:20 +0000404 (void)n_args;
Damien Georgefcdb2392014-10-06 13:45:34 +0000405
406 mp_int_t val = mp_obj_int_get_checked(args[0]);
Damien George963a5a32015-01-16 17:47:07 +0000407 mp_uint_t len = MP_OBJ_SMALL_INT_VALUE(args[1]);
Damien Georgefcdb2392014-10-06 13:45:34 +0000408
Damien George05005f62015-01-21 22:48:37 +0000409 vstr_t vstr;
410 vstr_init_len(&vstr, len);
411 byte *data = (byte*)vstr.buf;
Paul Sokolovskya985b452014-04-09 00:40:58 +0300412 memset(data, 0, len);
Damien Georgefcdb2392014-10-06 13:45:34 +0000413
414 if (MP_ENDIANNESS_LITTLE) {
415 memcpy(data, &val, len < sizeof(mp_int_t) ? len : sizeof(mp_int_t));
416 } else {
417 while (len--) {
418 *data++ = val;
419 val >>= 8;
420 }
421 }
422
Damien George05005f62015-01-21 22:48:37 +0000423 return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
Paul Sokolovskya985b452014-04-09 00:40:58 +0300424}
Paul Sokolovskya985b452014-04-09 00:40:58 +0300425STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(int_to_bytes_obj, 2, 4, int_to_bytes);
426
427STATIC const mp_map_elem_t int_locals_dict_table[] = {
428 { MP_OBJ_NEW_QSTR(MP_QSTR_from_bytes), (mp_obj_t)&int_from_bytes_obj },
429 { MP_OBJ_NEW_QSTR(MP_QSTR_to_bytes), (mp_obj_t)&int_to_bytes_obj },
430};
431
432STATIC MP_DEFINE_CONST_DICT(int_locals_dict, int_locals_dict_table);
433
Damien George3e1a5c12014-03-29 13:43:38 +0000434const mp_obj_type_t mp_type_int = {
Damien Georgec5966122014-02-15 16:10:44 +0000435 { &mp_type_type },
Damien Georgea71c83a2014-02-15 11:34:50 +0000436 .name = MP_QSTR_int,
Damien Georgee8208a72014-04-04 15:08:23 +0100437 .print = mp_obj_int_print,
438 .make_new = mp_obj_int_make_new,
439 .unary_op = mp_obj_int_unary_op,
440 .binary_op = mp_obj_int_binary_op,
Paul Sokolovskya985b452014-04-09 00:40:58 +0300441 .locals_dict = (mp_obj_t)&int_locals_dict,
Damien George5fa93b62014-01-22 14:35:10 +0000442};