From 37379a2974190ab0fc97f840112d5a40c907368b Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Tue, 29 Aug 2017 00:06:21 +0300 Subject: py/objstr: startswith, endswith: Check arg to be a string. Otherwise, it will silently get incorrect result on other values types, including CPython tuple form like "foo.png".endswith(("png", "jpg")) (which MicroPython doesn't support for unbloatedness). --- tests/basics/string_endswith.py | 5 +++++ tests/basics/string_endswith_upy.py | 6 ++++++ tests/basics/string_endswith_upy.py.exp | 1 + tests/basics/string_startswith.py | 5 +++++ tests/basics/string_startswith_upy.py | 6 ++++++ tests/basics/string_startswith_upy.py.exp | 1 + 6 files changed, 24 insertions(+) create mode 100644 tests/basics/string_endswith_upy.py create mode 100644 tests/basics/string_endswith_upy.py.exp create mode 100644 tests/basics/string_startswith_upy.py create mode 100644 tests/basics/string_startswith_upy.py.exp (limited to 'tests') diff --git a/tests/basics/string_endswith.py b/tests/basics/string_endswith.py index 3e8fba925..683562d10 100644 --- a/tests/basics/string_endswith.py +++ b/tests/basics/string_endswith.py @@ -10,3 +10,8 @@ print("foobar".endswith("foobarbaz")) #print("1foo".startswith("1foo", 1)) #print("1fo".startswith("foo", 1)) #print("1fo".startswith("foo", 10)) + +try: + "foobar".endswith(1) +except TypeError: + print("TypeError") diff --git a/tests/basics/string_endswith_upy.py b/tests/basics/string_endswith_upy.py new file mode 100644 index 000000000..06a4e71d2 --- /dev/null +++ b/tests/basics/string_endswith_upy.py @@ -0,0 +1,6 @@ +# MicroPython doesn't support tuple argument + +try: + "foobar".endswith(("bar", "sth")) +except TypeError: + print("TypeError") diff --git a/tests/basics/string_endswith_upy.py.exp b/tests/basics/string_endswith_upy.py.exp new file mode 100644 index 000000000..6002b71c5 --- /dev/null +++ b/tests/basics/string_endswith_upy.py.exp @@ -0,0 +1 @@ +TypeError diff --git a/tests/basics/string_startswith.py b/tests/basics/string_startswith.py index 5cf730c03..e63ae3c18 100644 --- a/tests/basics/string_startswith.py +++ b/tests/basics/string_startswith.py @@ -9,3 +9,8 @@ print("1foo".startswith("foo", 1)) print("1foo".startswith("1foo", 1)) print("1fo".startswith("foo", 1)) print("1fo".startswith("foo", 10)) + +try: + "foobar".startswith(1) +except TypeError: + print("TypeError") diff --git a/tests/basics/string_startswith_upy.py b/tests/basics/string_startswith_upy.py new file mode 100644 index 000000000..9ea1796c2 --- /dev/null +++ b/tests/basics/string_startswith_upy.py @@ -0,0 +1,6 @@ +# MicroPython doesn't support tuple argument + +try: + "foobar".startswith(("foo", "sth")) +except TypeError: + print("TypeError") diff --git a/tests/basics/string_startswith_upy.py.exp b/tests/basics/string_startswith_upy.py.exp new file mode 100644 index 000000000..6002b71c5 --- /dev/null +++ b/tests/basics/string_startswith_upy.py.exp @@ -0,0 +1 @@ +TypeError -- cgit v1.2.3 From 784909ce1655bf8b2a97ac81a3842e844992082f Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Wed, 30 Aug 2017 01:35:48 +0300 Subject: py/objtype: Handle NotImplemented return from binary special methods. NotImplemented means "try other fallbacks (like calling __rop__ instead of __op__) and if nothing works, raise TypeError". As MicroPython doesn't implement any fallbacks, signal to raise TypeError right away. --- py/obj.h | 1 + py/objtype.c | 18 ++++++++++++++-- tests/basics/class_notimpl.py | 50 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 67 insertions(+), 2 deletions(-) create mode 100644 tests/basics/class_notimpl.py (limited to 'tests') diff --git a/py/obj.h b/py/obj.h index 2adcab1a6..323423b3e 100644 --- a/py/obj.h +++ b/py/obj.h @@ -616,6 +616,7 @@ extern const mp_obj_type_t mp_type_ZeroDivisionError; #define mp_const_true (MP_OBJ_FROM_PTR(&mp_const_true_obj)) #define mp_const_empty_bytes (MP_OBJ_FROM_PTR(&mp_const_empty_bytes_obj)) #define mp_const_empty_tuple (MP_OBJ_FROM_PTR(&mp_const_empty_tuple_obj)) +#define mp_const_notimplemented (MP_OBJ_FROM_PTR(&mp_const_notimplemented_obj)) extern const struct _mp_obj_none_t mp_const_none_obj; extern const struct _mp_obj_bool_t mp_const_false_obj; extern const struct _mp_obj_bool_t mp_const_true_obj; diff --git a/py/objtype.c b/py/objtype.c index 08e276d72..4973236a4 100644 --- a/py/objtype.c +++ b/py/objtype.c @@ -471,14 +471,28 @@ STATIC mp_obj_t instance_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t .is_type = false, }; mp_obj_class_lookup(&lookup, lhs->base.type); + + mp_obj_t res; if (dest[0] == MP_OBJ_SENTINEL) { - return mp_binary_op(op, lhs->subobj[0], rhs_in); + res = mp_binary_op(op, lhs->subobj[0], rhs_in); } else if (dest[0] != MP_OBJ_NULL) { dest[2] = rhs_in; - return mp_call_method_n_kw(1, 0, dest); + res = mp_call_method_n_kw(1, 0, dest); } else { return MP_OBJ_NULL; // op not supported } + + #if MICROPY_PY_BUILTINS_NOTIMPLEMENTED + // NotImplemented means "try other fallbacks (like calling __rop__ + // instead of __op__) and if nothing works, raise TypeError". As + // MicroPython doesn't implement any fallbacks, signal to raise + // TypeError right away. + if (res == mp_const_notimplemented) { + return MP_OBJ_NULL; // op not supported + } + #endif + + return res; } STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { diff --git a/tests/basics/class_notimpl.py b/tests/basics/class_notimpl.py new file mode 100644 index 000000000..7fd8166f9 --- /dev/null +++ b/tests/basics/class_notimpl.py @@ -0,0 +1,50 @@ +# Test that returning of NotImplemented from binary op methods leads to +# TypeError. +try: + NotImplemented +except NameError: + print("SKIP") + raise SystemExit + +class C: + def __init__(self, value): + self.value = value + + def __str__(self): + return "C(%s)" % self.value + + def __add__(self, rhs): + print(self, '+', rhs) + return NotImplemented + + def __sub__(self, rhs): + print(self, '-', rhs) + return NotImplemented + + def __lt__(self, rhs): + print(self, '<', rhs) + return NotImplemented + + def __neg__(self): + print('-', self) + return NotImplemented + +c = C(0) + +try: + c + 1 +except TypeError: + print("TypeError") + +try: + c - 2 +except TypeError: + print("TypeError") + +try: + c < 1 +except TypeError: + print("TypeError") + +# NotImplemented isn't handled specially in unary methods +print(-c) -- cgit v1.2.3 From b565c36963178817fedec4971c6719ea96987c71 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Wed, 30 Aug 2017 21:29:23 +0300 Subject: tests/object_new: Better messages, check user __new__() method. Make messages more verbose and easier to follow and check that user class' __new__() is not called by object.__new__(user_class). --- tests/basics/object_new.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) (limited to 'tests') diff --git a/tests/basics/object_new.py b/tests/basics/object_new.py index a9c9482cb..1bf7bc0ec 100644 --- a/tests/basics/object_new.py +++ b/tests/basics/object_new.py @@ -12,6 +12,11 @@ except AttributeError: class Foo: + def __new__(cls): + # Should not be called in this test + print("in __new__") + raise RuntimeError + def __init__(self): print("in __init__") self.attr = "something" @@ -19,12 +24,13 @@ class Foo: o = object.__new__(Foo) #print(o) -print(hasattr(o, "attr")) -print(isinstance(o, Foo)) +print("Result of __new__ has .attr:", hasattr(o, "attr")) +print("Result of __new__ is already a Foo:", isinstance(o, Foo)) + o.__init__() #print(dir(o)) -print(hasattr(o, "attr")) -print(o.attr) +print("After __init__ has .attr:", hasattr(o, "attr")) +print(".attr:", o.attr) # should only be able to call __new__ on user types try: -- cgit v1.2.3 From 35be9e805fcdc1e0d541b64b62e381fa0b490812 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Wed, 30 Aug 2017 21:33:42 +0300 Subject: tests/class_new: Add checks for __init__ being called and other improvements. --- tests/basics/class_new.py | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) (limited to 'tests') diff --git a/tests/basics/class_new.py b/tests/basics/class_new.py index 9a7072ad0..4912f71f0 100644 --- a/tests/basics/class_new.py +++ b/tests/basics/class_new.py @@ -5,13 +5,14 @@ try: except AttributeError: print("SKIP") raise SystemExit + class A: def __new__(cls): print("A.__new__") return super(cls, A).__new__(cls) def __init__(self): - pass + print("A.__init__") def meth(self): print('A.meth') @@ -35,5 +36,10 @@ a.meth() class B: def __new__(self, v1, v2): - None -B(1, 2) + print("B.__new__", v1, v2) + + def __init__(self, v1, v2): + # Should not be called in this test + print("B.__init__", v1, v2) + +print("B inst:", B(1, 2)) -- cgit v1.2.3 From b349479a49aab440b2f38fc6e45b3df4bf7a1aa7 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Fri, 1 Sep 2017 00:39:06 +0300 Subject: tests/class_new: Add another testcase for __new__/__init__ interaction. Similar to the existing testcase, but test that returning both value of native type and instance of another user class from __new__ lead to __init__ not being called, for better coverage. --- tests/basics/class_new.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) (limited to 'tests') diff --git a/tests/basics/class_new.py b/tests/basics/class_new.py index 4912f71f0..1f6a86c64 100644 --- a/tests/basics/class_new.py +++ b/tests/basics/class_new.py @@ -34,6 +34,9 @@ a.meth() a = a.__new__(A) a.meth() +# __new__ returns not an instance of the class (None here), __init__ +# should not be called + class B: def __new__(self, v1, v2): print("B.__new__", v1, v2) @@ -43,3 +46,21 @@ class B: print("B.__init__", v1, v2) print("B inst:", B(1, 2)) + + +# Variation of the above, __new__ returns an instance of another class, +# __init__ should not be called + +class Dummy: pass + +class C: + def __new__(cls): + print("C.__new__") + return Dummy() + + def __init__(self): + # Should not be called in this test + print("C.__init__") + +c = C() +print(isinstance(c, Dummy)) -- cgit v1.2.3 From 793d826d9df67c3f544505beda63ca36d8dfa1c4 Mon Sep 17 00:00:00 2001 From: Damien George Date: Fri, 1 Sep 2017 10:10:51 +1000 Subject: py/modstruct: In struct.pack, stop converting if there are no args left. This patch makes a repeat counter behave the same as repeating the typecode, when there are not enough args. For example: struct.pack('2I', 1) now behave the same as struct.pack('II', 1). --- py/modstruct.c | 3 ++- tests/basics/struct_micropython.py | 3 +++ tests/basics/struct_micropython.py.exp | 1 + 3 files changed, 6 insertions(+), 1 deletion(-) (limited to 'tests') diff --git a/py/modstruct.c b/py/modstruct.c index 1daa33338..0d4a45f6b 100644 --- a/py/modstruct.c +++ b/py/modstruct.c @@ -206,7 +206,8 @@ STATIC void struct_pack_into_internal(mp_obj_t fmt_in, byte *p, byte* end_p, siz memset(p + to_copy, 0, sz - to_copy); p += sz; } else { - while (sz--) { + // If we run out of args then we just finish; CPython would raise struct.error + while (sz-- && i < n_args) { mp_binary_set_val(fmt_type, *fmt, args[i++], &p); } } diff --git a/tests/basics/struct_micropython.py b/tests/basics/struct_micropython.py index 4b9dfe137..f203a4666 100644 --- a/tests/basics/struct_micropython.py +++ b/tests/basics/struct_micropython.py @@ -18,6 +18,9 @@ s = struct.pack(" Date: Fri, 1 Sep 2017 10:53:29 +1000 Subject: py/modstruct: Check and prevent buffer-read overflow in struct unpacking Prior to this patch, the size of the buffer given to unpack/unpack_from was checked for being too small by using the count of the arguments, not their actual size. For example, a format spec of '4I' would only check that there was 4 bytes available, not 16; and 'I' would check for 1 byte, not 4. This bug is fixed in this patch by calculating the total size of the format spec at the start of the unpacking function. This function anyway needs to calculate the number of items at the start, so calculating the total size can be done at the same time. --- py/modstruct.c | 55 +++++++++++++++++++++++-------------------------- tests/basics/struct1.py | 6 ++++++ tests/basics/struct2.py | 6 ++++++ 3 files changed, 38 insertions(+), 29 deletions(-) (limited to 'tests') diff --git a/py/modstruct.c b/py/modstruct.c index 0d4a45f6b..61dd0f81b 100644 --- a/py/modstruct.c +++ b/py/modstruct.c @@ -82,26 +82,10 @@ STATIC mp_uint_t get_fmt_num(const char **p) { return val; } -STATIC uint calcsize_items(const char *fmt) { - uint cnt = 0; - while (*fmt) { - int num = 1; - if (unichar_isdigit(*fmt)) { - num = get_fmt_num(&fmt); - if (*fmt == 's') { - num = 1; - } - } - cnt += num; - fmt++; - } - return cnt; -} - -STATIC mp_obj_t struct_calcsize(mp_obj_t fmt_in) { - const char *fmt = mp_obj_str_get_str(fmt_in); +STATIC size_t calc_size_items(const char *fmt, size_t *total_sz) { char fmt_type = get_fmt_type(&fmt); - mp_uint_t size; + size_t total_cnt = 0; + size_t size; for (size = 0; *fmt; fmt++) { mp_uint_t cnt = 1; if (unichar_isdigit(*fmt)) { @@ -109,8 +93,10 @@ STATIC mp_obj_t struct_calcsize(mp_obj_t fmt_in) { } if (*fmt == 's') { + total_cnt += 1; size += cnt; } else { + total_cnt += cnt; mp_uint_t align; size_t sz = mp_binary_get_size(fmt_type, *fmt, &align); while (cnt--) { @@ -120,6 +106,14 @@ STATIC mp_obj_t struct_calcsize(mp_obj_t fmt_in) { } } } + *total_sz = size; + return total_cnt; +} + +STATIC mp_obj_t struct_calcsize(mp_obj_t fmt_in) { + const char *fmt = mp_obj_str_get_str(fmt_in); + size_t size; + calc_size_items(fmt, &size); return MP_OBJ_NEW_SMALL_INT(size); } MP_DEFINE_CONST_FUN_OBJ_1(struct_calcsize_obj, struct_calcsize); @@ -130,8 +124,9 @@ STATIC mp_obj_t struct_unpack_from(size_t n_args, const mp_obj_t *args) { // Since we implement unpack and unpack_from using the same function // we relax the "exact" requirement, and only implement "big enough". const char *fmt = mp_obj_str_get_str(args[0]); + size_t total_sz; + size_t num_items = calc_size_items(fmt, &total_sz); char fmt_type = get_fmt_type(&fmt); - uint num_items = calcsize_items(fmt); mp_obj_tuple_t *res = MP_OBJ_TO_PTR(mp_obj_new_tuple(num_items, NULL)); mp_buffer_info_t bufinfo; mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ); @@ -152,21 +147,23 @@ STATIC mp_obj_t struct_unpack_from(size_t n_args, const mp_obj_t *args) { p += offset; } - for (uint i = 0; i < num_items;) { - mp_uint_t sz = 1; + // Check that the input buffer is big enough to unpack all the values + if (p + total_sz > end_p) { + mp_raise_ValueError("buffer too small"); + } + + for (size_t i = 0; i < num_items;) { + mp_uint_t cnt = 1; if (unichar_isdigit(*fmt)) { - sz = get_fmt_num(&fmt); - } - if (p + sz > end_p) { - mp_raise_ValueError("buffer too small"); + cnt = get_fmt_num(&fmt); } mp_obj_t item; if (*fmt == 's') { - item = mp_obj_new_bytes(p, sz); - p += sz; + item = mp_obj_new_bytes(p, cnt); + p += cnt; res->items[i++] = item; } else { - while (sz--) { + while (cnt--) { item = mp_binary_get_val(fmt_type, *fmt, &p); res->items[i++] = item; } diff --git a/tests/basics/struct1.py b/tests/basics/struct1.py index a442beb1e..2cf75137b 100644 --- a/tests/basics/struct1.py +++ b/tests/basics/struct1.py @@ -39,6 +39,12 @@ print(v == (10, 100, 200, 300)) # network byte order print(struct.pack('!i', 123)) +# check that we get an error if the buffer is too small +try: + struct.unpack('I', b'\x00\x00\x00') +except: + print('struct.error') + # first arg must be a string try: struct.pack(1, 2) diff --git a/tests/basics/struct2.py b/tests/basics/struct2.py index 3b9dd5c1f..e3336c0c7 100644 --- a/tests/basics/struct2.py +++ b/tests/basics/struct2.py @@ -25,6 +25,12 @@ print(struct.calcsize('0s1s0H2H')) print(struct.unpack('<0s1s0H2H', b'01234')) print(struct.pack('<0s1s0H2H', b'abc', b'abc', 258, 515)) +# check that we get an error if the buffer is too small +try: + struct.unpack('2H', b'\x00\x00') +except: + print('Exception') + # check that unknown types raise an exception try: struct.unpack('z', b'1') -- cgit v1.2.3 From 2daacc5ceef7e36ac3c88b8946088b6b3513993b Mon Sep 17 00:00:00 2001 From: Damien George Date: Fri, 1 Sep 2017 11:11:09 +1000 Subject: py/modstruct: Check and prevent buffer-write overflow in struct packing. Prior to this patch, the size of the buffer given to pack_into() was checked for being too small by using the count of the arguments, not their actual size. For example, a format spec of '4I' would only check that there was 4 bytes available, not 16; and 'I' would check for 1 byte, not 4. The pack() function is ok because its buffer is created to be exactly the correct size. The fix in this patch calculates the total size of the format spec at the start of pack_into() and verifies that the buffer is large enough. This adds some computational overhead, to iterate through the whole format spec. The alternative is to check during the packing, but that requires extra code to handle alignment, and the check is anyway not needed for pack(). So to maintain minimal code size the check is done using struct_calcsize. --- py/modstruct.c | 29 ++++++++++++++++------------- tests/basics/struct1.py | 6 ++++++ tests/basics/struct2.py | 4 ++++ 3 files changed, 26 insertions(+), 13 deletions(-) (limited to 'tests') diff --git a/py/modstruct.c b/py/modstruct.c index 61dd0f81b..8617a8e0d 100644 --- a/py/modstruct.c +++ b/py/modstruct.c @@ -174,37 +174,35 @@ STATIC mp_obj_t struct_unpack_from(size_t n_args, const mp_obj_t *args) { } MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(struct_unpack_from_obj, 2, 3, struct_unpack_from); -STATIC void struct_pack_into_internal(mp_obj_t fmt_in, byte *p, byte* end_p, size_t n_args, const mp_obj_t *args) { +// This function assumes there is enough room in p to store all the values +STATIC void struct_pack_into_internal(mp_obj_t fmt_in, byte *p, size_t n_args, const mp_obj_t *args) { const char *fmt = mp_obj_str_get_str(fmt_in); char fmt_type = get_fmt_type(&fmt); size_t i; for (i = 0; i < n_args;) { - mp_uint_t sz = 1; + mp_uint_t cnt = 1; if (*fmt == '\0') { // more arguments given than used by format string; CPython raises struct.error here break; } if (unichar_isdigit(*fmt)) { - sz = get_fmt_num(&fmt); - } - if (p + sz > end_p) { - mp_raise_ValueError("buffer too small"); + cnt = get_fmt_num(&fmt); } if (*fmt == 's') { mp_buffer_info_t bufinfo; mp_get_buffer_raise(args[i++], &bufinfo, MP_BUFFER_READ); - mp_uint_t to_copy = sz; + mp_uint_t to_copy = cnt; if (bufinfo.len < to_copy) { to_copy = bufinfo.len; } memcpy(p, bufinfo.buf, to_copy); - memset(p + to_copy, 0, sz - to_copy); - p += sz; + memset(p + to_copy, 0, cnt - to_copy); + p += cnt; } else { // If we run out of args then we just finish; CPython would raise struct.error - while (sz-- && i < n_args) { + while (cnt-- && i < n_args) { mp_binary_set_val(fmt_type, *fmt, args[i++], &p); } } @@ -219,8 +217,7 @@ STATIC mp_obj_t struct_pack(size_t n_args, const mp_obj_t *args) { vstr_init_len(&vstr, size); byte *p = (byte*)vstr.buf; memset(p, 0, size); - byte *end_p = &p[size]; - struct_pack_into_internal(args[0], p, end_p, n_args - 1, &args[1]); + struct_pack_into_internal(args[0], p, n_args - 1, &args[1]); return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr); } MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(struct_pack_obj, 1, MP_OBJ_FUN_ARGS_MAX, struct_pack); @@ -240,7 +237,13 @@ STATIC mp_obj_t struct_pack_into(size_t n_args, const mp_obj_t *args) { byte *end_p = &p[bufinfo.len]; p += offset; - struct_pack_into_internal(args[0], p, end_p, n_args - 3, &args[3]); + // Check that the output buffer is big enough to hold all the values + mp_int_t sz = MP_OBJ_SMALL_INT_VALUE(struct_calcsize(args[0])); + if (p + sz > end_p) { + mp_raise_ValueError("buffer too small"); + } + + struct_pack_into_internal(args[0], p, n_args - 3, &args[3]); return mp_const_none; } MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(struct_pack_into_obj, 3, MP_OBJ_FUN_ARGS_MAX, struct_pack_into); diff --git a/tests/basics/struct1.py b/tests/basics/struct1.py index 2cf75137b..db34342a1 100644 --- a/tests/basics/struct1.py +++ b/tests/basics/struct1.py @@ -69,6 +69,12 @@ print(buf) struct.pack_into(' Date: Sat, 2 Sep 2017 21:19:01 +0300 Subject: py/objfloat: Fix binary ops with incompatible objects. These are now returned as "operation not supported" instead of raising TypeError. In particular, this fixes equality for float vs incompatible types, which now properly results in False instead of exception. This also paves the road to support reverse operation (e.g. __radd__) with float objects. This is achieved by introducing mp_obj_get_float_maybe(), similar to existing mp_obj_get_int_maybe(). --- py/obj.c | 27 +++++++++++++++++++++------ py/obj.h | 1 + py/objfloat.c | 6 +++++- tests/float/float_compare.py | 22 ++++++++++++++++++++++ 4 files changed, 49 insertions(+), 7 deletions(-) create mode 100644 tests/float/float_compare.py (limited to 'tests') diff --git a/py/obj.c b/py/obj.c index 0dab5f2ac..90ce47e8f 100644 --- a/py/obj.c +++ b/py/obj.c @@ -264,20 +264,33 @@ bool mp_obj_get_int_maybe(mp_const_obj_t arg, mp_int_t *value) { } #if MICROPY_PY_BUILTINS_FLOAT -mp_float_t mp_obj_get_float(mp_obj_t arg) { +bool mp_obj_get_float_maybe(mp_obj_t arg, mp_float_t *value) { + mp_float_t val; + if (arg == mp_const_false) { - return 0; + val = 0; } else if (arg == mp_const_true) { - return 1; + val = 1; } else if (MP_OBJ_IS_SMALL_INT(arg)) { - return MP_OBJ_SMALL_INT_VALUE(arg); + val = MP_OBJ_SMALL_INT_VALUE(arg); #if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE } else if (MP_OBJ_IS_TYPE(arg, &mp_type_int)) { - return mp_obj_int_as_float_impl(arg); + val = mp_obj_int_as_float_impl(arg); #endif } else if (mp_obj_is_float(arg)) { - return mp_obj_float_get(arg); + val = mp_obj_float_get(arg); } else { + return false; + } + + *value = val; + return true; +} + +mp_float_t mp_obj_get_float(mp_obj_t arg) { + mp_float_t val; + + if (!mp_obj_get_float_maybe(arg, &val)) { if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) { mp_raise_TypeError("can't convert to float"); } else { @@ -285,6 +298,8 @@ mp_float_t mp_obj_get_float(mp_obj_t arg) { "can't convert %s to float", mp_obj_get_type_str(arg))); } } + + return val; } #if MICROPY_PY_BUILTINS_COMPLEX diff --git a/py/obj.h b/py/obj.h index 323423b3e..70cdd15fa 100644 --- a/py/obj.h +++ b/py/obj.h @@ -686,6 +686,7 @@ mp_int_t mp_obj_get_int_truncated(mp_const_obj_t arg); bool mp_obj_get_int_maybe(mp_const_obj_t arg, mp_int_t *value); #if MICROPY_PY_BUILTINS_FLOAT mp_float_t mp_obj_get_float(mp_obj_t self_in); +bool mp_obj_get_float_maybe(mp_obj_t arg, mp_float_t *value); void mp_obj_get_complex(mp_obj_t self_in, mp_float_t *real, mp_float_t *imag); #endif //qstr mp_obj_get_qstr(mp_obj_t arg); diff --git a/py/objfloat.c b/py/objfloat.c index b1900b236..fadbbcb79 100644 --- a/py/objfloat.c +++ b/py/objfloat.c @@ -240,7 +240,11 @@ STATIC void mp_obj_float_divmod(mp_float_t *x, mp_float_t *y) { } mp_obj_t mp_obj_float_binary_op(mp_binary_op_t op, mp_float_t lhs_val, mp_obj_t rhs_in) { - mp_float_t rhs_val = mp_obj_get_float(rhs_in); // can be any type, this function will convert to float (if possible) + mp_float_t rhs_val; + if (!mp_obj_get_float_maybe(rhs_in, &rhs_val)) { + return MP_OBJ_NULL; // op not supported + } + switch (op) { case MP_BINARY_OP_ADD: case MP_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break; diff --git a/tests/float/float_compare.py b/tests/float/float_compare.py new file mode 100644 index 000000000..105923ac7 --- /dev/null +++ b/tests/float/float_compare.py @@ -0,0 +1,22 @@ +# Extended float comparisons + +class Foo: + pass + +foo = Foo() + +print(foo == 1.0) +print(1.0 == foo) +print(1.0 == Foo) +print(1.0 == []) +print(1.0 == {}) + +try: + print(foo < 1.0) +except TypeError: + print("TypeError") + +try: + print(1.0 < foo) +except TypeError: + print("TypeError") -- cgit v1.2.3 From d4b75f6b6822885e331c69a74e56e23af40a6264 Mon Sep 17 00:00:00 2001 From: Damien George Date: Mon, 4 Sep 2017 14:16:27 +1000 Subject: py/obj: Fix comparison of float/complex NaN with itself. IEEE floating point is specified such that a comparison of NaN with itself returns false, and Python respects these semantics. This patch makes uPy also have these semantics. The fix has a minor impact on the speed of the object-equality fast-path, but that seems to be unavoidable and it's much more important to have correct behaviour (especially in this case where the wrong answer for nan==nan is silently returned). --- py/obj.c | 11 ++++++++++- tests/float/complex1.py | 5 +++++ tests/float/float1.py | 5 +++++ 3 files changed, 20 insertions(+), 1 deletion(-) (limited to 'tests') diff --git a/py/obj.c b/py/obj.c index 90ce47e8f..857fe373f 100644 --- a/py/obj.c +++ b/py/obj.c @@ -162,7 +162,16 @@ bool mp_obj_is_callable(mp_obj_t o_in) { // comparison returns NotImplemented, == and != are decided by comparing the object // pointer." bool mp_obj_equal(mp_obj_t o1, mp_obj_t o2) { - if (o1 == o2) { + // Float (and complex) NaN is never equal to anything, not even itself, + // so we must have a special check here to cover those cases. + if (o1 == o2 + #if MICROPY_PY_BUILTINS_FLOAT + && !mp_obj_is_float(o1) + #endif + #if MICROPY_PY_BUILTINS_COMPLEX + && !MP_OBJ_IS_TYPE(o1, &mp_type_complex) + #endif + ) { return true; } if (o1 == mp_const_none || o2 == mp_const_none) { diff --git a/tests/float/complex1.py b/tests/float/complex1.py index a6038de04..7f0b317b3 100644 --- a/tests/float/complex1.py +++ b/tests/float/complex1.py @@ -37,6 +37,11 @@ ans = 1j ** 2.5j; print("%.5g %.5g" % (ans.real, ans.imag)) print(1j == 1) print(1j == 1j) +# comparison of nan is special +nan = float('nan') * 1j +print(nan == 1j) +print(nan == nan) + # builtin abs print(abs(1j)) print("%.5g" % abs(1j + 2)) diff --git a/tests/float/float1.py b/tests/float/float1.py index 93f6f014c..137dacc23 100644 --- a/tests/float/float1.py +++ b/tests/float/float1.py @@ -60,6 +60,11 @@ print(1.2 <= -3.4) print(1.2 >= 3.4) print(1.2 >= -3.4) +# comparison of nan is special +nan = float('nan') +print(nan == 1.2) +print(nan == nan) + try: 1.0 / 0 except ZeroDivisionError: -- cgit v1.2.3 From 376618cd8ad322f5a8fa77dac7d202f451481688 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Mon, 4 Sep 2017 16:44:38 +0300 Subject: tests/class_inplace_op: Test for inplace op fallback to normal one. --- tests/basics/class_inplace_op.py | 47 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 tests/basics/class_inplace_op.py (limited to 'tests') diff --git a/tests/basics/class_inplace_op.py b/tests/basics/class_inplace_op.py new file mode 100644 index 000000000..62aad8c7c --- /dev/null +++ b/tests/basics/class_inplace_op.py @@ -0,0 +1,47 @@ +# Case 1: Immutable object (e.g. number-like) +# __iadd__ should not be defined, will be emulated using __add__ + +class A: + + def __init__(self, v): + self.v = v + + def __add__(self, o): + return A(self.v + o.v) + + def __repr__(self): + return "A(%s)" % self.v + +a = A(5) +b = a +a += A(3) +print(a) +# Should be original a's value, i.e. A(5) +print(b) + +# Case 2: Mutable object (e.g. list-like) +# __iadd__ should be defined + +class L: + + def __init__(self, v): + self.v = v + + def __add__(self, o): + # Should not be caled in this test + print("L.__add__") + return L(self.v + o.v) + + def __iadd__(self, o): + self.v += o.v + return self + + def __repr__(self): + return "L(%s)" % self.v + +c = L([1, 2]) +d = c +c += L([3, 4]) +print(c) +# Should be updated c's value, i.e. L([1, 2, 3, 4]) +print(d) -- cgit v1.2.3 From 1aaba5cabe48fa5168279a51f62124bbfedd5d59 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Wed, 6 Sep 2017 00:23:41 +0300 Subject: py/objtuple: Properly implement comparison with incompatible types. Should raise TypeError, unless it's (in)equality comparison. --- py/objtuple.c | 11 +++++++---- tests/basics/tuple_compare.py | 10 ++++++++++ 2 files changed, 17 insertions(+), 4 deletions(-) (limited to 'tests') diff --git a/py/objtuple.c b/py/objtuple.c index 079b5cbdb..b8916a1a7 100644 --- a/py/objtuple.c +++ b/py/objtuple.c @@ -101,7 +101,7 @@ STATIC mp_obj_t mp_obj_tuple_make_new(const mp_obj_type_t *type_in, size_t n_arg } // Don't pass MP_BINARY_OP_NOT_EQUAL here -STATIC bool tuple_cmp_helper(mp_uint_t op, mp_obj_t self_in, mp_obj_t another_in) { +STATIC mp_obj_t tuple_cmp_helper(mp_uint_t op, mp_obj_t self_in, mp_obj_t another_in) { // type check is done on getiter method to allow tuple, namedtuple, attrtuple mp_check_self(mp_obj_get_type(self_in)->getiter == mp_obj_tuple_getiter); mp_obj_type_t *another_type = mp_obj_get_type(another_in); @@ -110,12 +110,15 @@ STATIC bool tuple_cmp_helper(mp_uint_t op, mp_obj_t self_in, mp_obj_t another_in // Slow path for user subclasses another_in = mp_instance_cast_to_native_base(another_in, MP_OBJ_FROM_PTR(&mp_type_tuple)); if (another_in == MP_OBJ_NULL) { - return false; + if (op == MP_BINARY_OP_EQUAL) { + return mp_const_false; + } + return MP_OBJ_NULL; } } mp_obj_tuple_t *another = MP_OBJ_TO_PTR(another_in); - return mp_seq_cmp_objs(op, self->items, self->len, another->items, another->len); + return mp_obj_new_bool(mp_seq_cmp_objs(op, self->items, self->len, another->items, another->len)); } mp_obj_t mp_obj_tuple_unary_op(mp_unary_op_t op, mp_obj_t self_in) { @@ -166,7 +169,7 @@ mp_obj_t mp_obj_tuple_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) { case MP_BINARY_OP_LESS_EQUAL: case MP_BINARY_OP_MORE: case MP_BINARY_OP_MORE_EQUAL: - return mp_obj_new_bool(tuple_cmp_helper(op, lhs, rhs)); + return tuple_cmp_helper(op, lhs, rhs); default: return MP_OBJ_NULL; // op not supported diff --git a/tests/basics/tuple_compare.py b/tests/basics/tuple_compare.py index ad813f702..9558eb1db 100644 --- a/tests/basics/tuple_compare.py +++ b/tests/basics/tuple_compare.py @@ -53,3 +53,13 @@ print((10, 0) > (1, 1)) print((10, 0) < (1, 1)) print((0, 0, 10, 0) > (0, 0, 1, 1)) print((0, 0, 10, 0) < (0, 0, 1, 1)) + + +print(() == {}) +print(() != {}) +print((1,) == [1]) + +try: + print(() < {}) +except TypeError: + print("TypeError") -- cgit v1.2.3 From 4a93801c12898898744131f57d79cf216d0861b3 Mon Sep 17 00:00:00 2001 From: Damien George Date: Wed, 6 Sep 2017 14:09:13 +1000 Subject: all: Update Makefiles and others to build with new ports/ dir layout. Also renames "stmhal" to "stm32" in documentation and everywhere else. --- .gitattributes | 11 -- .travis.yml | 46 ++++---- README.md | 34 +++--- docs/reference/constrained.rst | 2 +- examples/pins.py | 2 +- extmod/modframebuf.c | 2 +- mpy-cross/Makefile | 2 +- mpy-cross/main.c | 2 +- ports/bare-arm/Makefile | 2 +- ports/cc3200/Makefile | 2 +- ports/cc3200/application.mk | 4 +- ports/cc3200/bootmgr/bootloader.mk | 2 +- ports/esp8266/Makefile | 2 +- ports/esp8266/esp_mphal.h | 2 +- ports/esp8266/modules/ds18x20.py | 2 +- ports/esp8266/modules/onewire.py | 2 +- ports/esp8266/modules/upip.py | 2 +- ports/esp8266/modules/upip_utarfile.py | 2 +- ports/minimal/Makefile | 2 +- ports/pic16bit/Makefile | 2 +- ports/qemu-arm/Makefile | 2 +- ports/stm32/Makefile | 4 +- ports/stm32/README.md | 6 +- .../boards/NUCLEO_F401RE/stm32f4xx_hal_conf.h | 2 +- .../boards/NUCLEO_F411RE/stm32f4xx_hal_conf.h | 2 +- .../boards/NUCLEO_F446RE/stm32f4xx_hal_conf.h | 2 +- ports/stm32/help.c | 2 +- ports/stm32/modules/lcd160cr.py | 2 +- ports/stm32/modules/lcd160cr_test.py | 2 +- ports/stm32/modules/onewire.py | 2 +- ports/stm32/mpconfigport.h | 4 +- ports/stm32/mphalport.h | 4 +- ports/stm32/pin_defs_stm32.c | 31 +++++ ports/stm32/pin_defs_stm32.h | 131 +++++++++++++++++++++ ports/stm32/pin_defs_stmhal.c | 31 ----- ports/stm32/pin_defs_stmhal.h | 131 --------------------- ports/teensy/Makefile | 8 +- ports/teensy/lcd.c | 2 +- ports/unix/Makefile | 6 +- ports/unix/modules/upip.py | 2 +- ports/unix/modules/upip_utarfile.py | 2 +- ports/windows/.appveyor.yml | 2 +- ports/windows/Makefile | 16 +-- ports/windows/README.md | 4 +- ports/windows/msvc/genhdr.targets | 2 +- ports/windows/msvc/paths.props | 26 ++-- ports/windows/msvc/sources.props | 22 ++-- ports/windows/windows_mphal.h | 2 +- ports/zephyr/Makefile | 2 +- py/mkrules.mk | 2 +- tests/run-tests | 4 +- tools/check_code_size.sh | 2 +- tools/codestats.sh | 44 +++---- 53 files changed, 311 insertions(+), 322 deletions(-) create mode 100644 ports/stm32/pin_defs_stm32.c create mode 100644 ports/stm32/pin_defs_stm32.h delete mode 100644 ports/stm32/pin_defs_stmhal.c delete mode 100644 ports/stm32/pin_defs_stmhal.h (limited to 'tests') diff --git a/.gitattributes b/.gitattributes index 6822bd21c..1ac507944 100644 --- a/.gitattributes +++ b/.gitattributes @@ -15,17 +15,6 @@ # These should also not be modified by git. tests/basics/string_cr_conversion.py -text tests/basics/string_crlf_conversion.py -text -stmhal/pybcdc.inf_template -text -stmhal/usbd_* -text -stmhal/boards/*/stm32f4xx_hal_conf.h -text -stmhal/usbdev/** -text -stmhal/usbhost/** -text -cc3200/hal/aes.c -text -cc3200/hal/aes.h -text -cc3200/hal/des.c -text -cc3200/hal/i2s.c -text -cc3200/hal/i2s.h -text -cc3200/version.h -text ports/stm32/pybcdc.inf_template -text ports/stm32/usbd_* -text ports/stm32/boards/*/stm32f4xx_hal_conf.h -text diff --git a/.travis.yml b/.travis.yml index 14d5df0a4..db51567f1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -28,40 +28,40 @@ before_script: script: - make -C mpy-cross - - make -C minimal CROSS=1 build/firmware.bin - - ls -l minimal/build/firmware.bin + - make -C ports/minimal CROSS=1 build/firmware.bin + - ls -l ports/minimal/build/firmware.bin - tools/check_code_size.sh - mkdir -p ${HOME}/persist # Save new firmware for reference, but only if building a main branch, not a pull request - - 'if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then cp minimal/build/firmware.bin ${HOME}/persist/; fi' - - make -C unix deplibs - - make -C unix - - make -C unix nanbox - - make -C bare-arm - - make -C qemu-arm test - - make -C stmhal - - make -C stmhal BOARD=PYBV11 MICROPY_PY_WIZNET5K=1 MICROPY_PY_CC3K=1 - - make -C stmhal BOARD=STM32F769DISC - - make -C stmhal BOARD=STM32L476DISC - - make -C teensy - - make -C cc3200 BTARGET=application BTYPE=release - - make -C cc3200 BTARGET=bootloader BTYPE=release - - make -C windows CROSS_COMPILE=i686-w64-mingw32- + - 'if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then cp ports/minimal/build/firmware.bin ${HOME}/persist/; fi' + - make -C ports/unix deplibs + - make -C ports/unix + - make -C ports/unix nanbox + - make -C ports/bare-arm + - make -C ports/qemu-arm test + - make -C ports/stm32 + - make -C ports/stm32 BOARD=PYBV11 MICROPY_PY_WIZNET5K=1 MICROPY_PY_CC3K=1 + - make -C ports/stm32 BOARD=STM32F769DISC + - make -C ports/stm32 BOARD=STM32L476DISC + - make -C ports/teensy + - make -C ports/cc3200 BTARGET=application BTYPE=release + - make -C ports/cc3200 BTARGET=bootloader BTYPE=release + - make -C ports/windows CROSS_COMPILE=i686-w64-mingw32- # run tests without coverage info #- (cd tests && MICROPY_CPYTHON3=python3.4 ./run-tests) #- (cd tests && MICROPY_CPYTHON3=python3.4 ./run-tests --emit native) # run tests with coverage info - - make -C unix coverage - - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../unix/micropython_coverage ./run-tests) - - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../unix/micropython_coverage ./run-tests -d thread) - - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../unix/micropython_coverage ./run-tests --emit native) - - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../unix/micropython_coverage ./run-tests --via-mpy -d basics float) + - make -C ports/unix coverage + - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../ports/unix/micropython_coverage ./run-tests) + - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../ports/unix/micropython_coverage ./run-tests -d thread) + - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../ports/unix/micropython_coverage ./run-tests --emit native) + - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../ports/unix/micropython_coverage ./run-tests --via-mpy -d basics float) # run coveralls coverage analysis (try to, even if some builds/tests failed) - - (cd unix && coveralls --root .. --build-root . --gcov $(which gcov) --gcov-options '\-o build-coverage/' --include py --include extmod) + - (cd ports/unix && coveralls --root ../.. --build-root . --gcov $(which gcov) --gcov-options '\-o build-coverage/' --include py --include extmod) after_failure: - (cd tests && for exp in *.exp; do testbase=$(basename $exp .exp); echo -e "\nFAILURE $testbase"; diff -u $testbase.exp $testbase.out; done) - - (grep "FAIL" qemu-arm/build/console.out) + - (grep "FAIL" ports/qemu-arm/build/console.out) diff --git a/README.md b/README.md index 481cac4e4..ff609dba3 100644 --- a/README.md +++ b/README.md @@ -34,10 +34,10 @@ Major components in this repository: core library. - mpy-cross/ -- the MicroPython cross-compiler which is used to turn scripts into precompiled bytecode. -- unix/ -- a version of MicroPython that runs on Unix. -- stmhal/ -- a version of MicroPython that runs on the PyBoard and similar +- ports/unix/ -- a version of MicroPython that runs on Unix. +- ports/stm32/ -- a version of MicroPython that runs on the PyBoard and similar STM32 boards (using ST's Cube HAL drivers). -- minimal/ -- a minimal MicroPython port. Start with this if you want +- ports/minimal/ -- a minimal MicroPython port. Start with this if you want to port MicroPython to another microcontroller. - tests/ -- test framework and test scripts. - docs/ -- user documentation in Sphinx reStructuredText format. Rendered @@ -45,13 +45,13 @@ Major components in this repository: to select needed board/port at the bottom left corner). Additional components: -- bare-arm/ -- a bare minimum version of MicroPython for ARM MCUs. Used +- ports/bare-arm/ -- a bare minimum version of MicroPython for ARM MCUs. Used mostly to control code size. -- teensy/ -- a version of MicroPython that runs on the Teensy 3.1 +- ports/teensy/ -- a version of MicroPython that runs on the Teensy 3.1 (preliminary but functional). -- pic16bit/ -- a version of MicroPython for 16-bit PIC microcontrollers. -- cc3200/ -- a version of MicroPython that runs on the CC3200 from TI. -- esp8266/ -- an experimental port for ESP8266 WiFi modules. +- ports/pic16bit/ -- a version of MicroPython for 16-bit PIC microcontrollers. +- ports/cc3200/ -- a version of MicroPython that runs on the CC3200 from TI. +- ports/esp8266/ -- an experimental port for ESP8266 WiFi modules. - extmod/ -- additional (non-core) modules implemented in C. - tools/ -- various tools, including the pyboard.py module. - examples/ -- a few example Python scripts. @@ -72,7 +72,7 @@ Alternatively, fallback implementation based on setjmp/longjmp can be used. To build (see section below for required dependencies): - $ cd unix + $ cd ports/unix $ make axtls $ make @@ -115,7 +115,7 @@ these additional dependencies, first fetch git submodules for them: $ git submodule update --init Use this same command to get the latest versions of dependencies, as -they are updated from time to time. After that, in `unix/` dir, execute: +they are updated from time to time. After that, in `ports/unix/` dir, execute: $ make deplibs @@ -123,25 +123,25 @@ This will build all available dependencies (regardless whether they are used or not). If you intend to build MicroPython with additional options (like cross-compiling), the same set of options should be passed to `make deplibs`. To actually enabled use of dependencies, edit -`unix/mpconfigport.mk` file, which has inline descriptions of the options. +`ports/unix/mpconfigport.mk` file, which has inline descriptions of the options. For example, to build SSL module (required for `upip` tool described above), set `MICROPY_PY_USSL` to 1. -In `unix/mpconfigport.mk`, you can also disable some dependencies enabled +In `ports/unix/mpconfigport.mk`, you can also disable some dependencies enabled by default, like FFI support, which requires libffi development files to be installed. -The STM version ---------------- +The STM32 version +----------------- -The "stmhal" port requires an ARM compiler, arm-none-eabi-gcc, and associated +The "stm32" port requires an ARM compiler, arm-none-eabi-gcc, and associated bin-utils. For those using Arch Linux, you need arm-none-eabi-binutils and arm-none-eabi-gcc packages. Otherwise, try here: https://launchpad.net/gcc-arm-embedded To build: - $ cd stmhal + $ cd ports/stm32 $ make You then need to get your board into DFU mode. On the pyboard, connect the @@ -155,4 +155,4 @@ Then to flash the code via USB DFU to your device: This will use the included `tools/pydfu.py` script. If flashing the firmware does not work it may be because you don't have the correct permissions, and need to use `sudo make deploy`. -See the README.md file in the stmhal/ directory for further details. +See the README.md file in the ports/stm32/ directory for further details. diff --git a/docs/reference/constrained.rst b/docs/reference/constrained.rst index 14286aa26..e7de459bc 100644 --- a/docs/reference/constrained.rst +++ b/docs/reference/constrained.rst @@ -279,7 +279,7 @@ After importing the modules, execute: Then copy and paste all the Q(xxx) lines into a text editor. Check for and remove lines which are obviously invalid. Open the file qstrdefsport.h which -will be found in stmhal (or the equivalent directory for the architecture in +will be found in ports/stm32 (or the equivalent directory for the architecture in use). Copy and paste the corrected lines at the end of the file. Save the file, rebuild and flash the firmware. The outcome can be checked by importing the modules and again issuing: diff --git a/examples/pins.py b/examples/pins.py index ab359f692..aafdb4813 100644 --- a/examples/pins.py +++ b/examples/pins.py @@ -1,5 +1,5 @@ # Print a nice list of pins, their current settings, and available afs. -# Requires pins_af.py from stmhal/build-PYBV10/ directory. +# Requires pins_af.py from ports/stm32/build-PYBV10/ directory. import pyb import pins_af diff --git a/extmod/modframebuf.c b/extmod/modframebuf.c index f4e857129..239302295 100644 --- a/extmod/modframebuf.c +++ b/extmod/modframebuf.c @@ -33,7 +33,7 @@ #if MICROPY_PY_FRAMEBUF -#include "stmhal/font_petme128_8x8.h" +#include "ports/stm32/font_petme128_8x8.h" typedef struct _mp_obj_framebuf_t { mp_obj_base_t base; diff --git a/mpy-cross/Makefile b/mpy-cross/Makefile index 5399b5ae7..53ce50c7f 100644 --- a/mpy-cross/Makefile +++ b/mpy-cross/Makefile @@ -65,7 +65,7 @@ SRC_C = \ # Add fmode when compiling with mingw gcc COMPILER_TARGET := $(shell $(CC) -dumpmachine) ifneq (,$(findstring mingw,$(COMPILER_TARGET))) - SRC_C += windows/fmode.c + SRC_C += ports/windows/fmode.c endif OBJ = $(PY_O) diff --git a/mpy-cross/main.c b/mpy-cross/main.c index ca8d9633f..225bc4309 100644 --- a/mpy-cross/main.c +++ b/mpy-cross/main.c @@ -36,7 +36,7 @@ #include "py/gc.h" #include "py/stackctrl.h" #ifdef _WIN32 -#include "windows/fmode.h" +#include "ports/windows/fmode.h" #endif // Command line options, with their defaults diff --git a/ports/bare-arm/Makefile b/ports/bare-arm/Makefile index 90c13de11..0fcd5d027 100644 --- a/ports/bare-arm/Makefile +++ b/ports/bare-arm/Makefile @@ -1,4 +1,4 @@ -include ../py/mkenv.mk +include ../../py/mkenv.mk # qstr definitions (must come before including py.mk) QSTR_DEFS = qstrdefsport.h diff --git a/ports/cc3200/Makefile b/ports/cc3200/Makefile index 4c8b0b832..81531b108 100644 --- a/ports/cc3200/Makefile +++ b/ports/cc3200/Makefile @@ -14,7 +14,7 @@ PORT ?= /dev/ttyUSB1 # If the build directory is not given, make it reflect the board name. BUILD ?= build/$(BOARD)/$(BTYPE) -include ../py/mkenv.mk +include ../../py/mkenv.mk -include ../../localconfig.mk CROSS_COMPILE ?= arm-none-eabi- diff --git a/ports/cc3200/application.mk b/ports/cc3200/application.mk index 64891a2e7..19abe6616 100644 --- a/ports/cc3200/application.mk +++ b/ports/cc3200/application.mk @@ -18,7 +18,7 @@ APP_INC += -Iutil APP_INC += -Ibootmgr APP_INC += -I$(BUILD) APP_INC += -I$(BUILD)/genhdr -APP_INC += -I$(TOP)/stmhal +APP_INC += -I$(TOP)/ports/stm32 APP_CPPDEFINES = -Dgcc -DTARGET_IS_CC3200 -DSL_FULL -DUSE_FREERTOS @@ -151,7 +151,7 @@ APP_LIB_SRC_C = $(addprefix lib/,\ utils/sys_stdio_mphal.c \ ) -APP_STM_SRC_C = $(addprefix stmhal/,\ +APP_STM_SRC_C = $(addprefix ports/stm32/,\ bufhelper.c \ irq.c \ ) diff --git a/ports/cc3200/bootmgr/bootloader.mk b/ports/cc3200/bootmgr/bootloader.mk index b8aa9082c..44f1b7f42 100644 --- a/ports/cc3200/bootmgr/bootloader.mk +++ b/ports/cc3200/bootmgr/bootloader.mk @@ -98,7 +98,7 @@ $(BUILD)/misc/%.o: CFLAGS += -Os $(BUILD)/simplelink/%.o: CFLAGS += -Os $(BUILD)/drivers/cc3100/%.o: CFLAGS += -Os $(BUILD)/py/%.o: CFLAGS += -Os -$(BUILD)/stmhal/%.o: CFLAGS += -Os +$(BUILD)/ports/stm32/%.o: CFLAGS += -Os else $(error Invalid BTYPE specified) endif diff --git a/ports/esp8266/Makefile b/ports/esp8266/Makefile index fce11a7d4..70b4ce35c 100644 --- a/ports/esp8266/Makefile +++ b/ports/esp8266/Makefile @@ -1,4 +1,4 @@ -include ../py/mkenv.mk +include ../../py/mkenv.mk # qstr definitions (must come before including py.mk) QSTR_DEFS = qstrdefsport.h #$(BUILD)/pins_qstr.h diff --git a/ports/esp8266/esp_mphal.h b/ports/esp8266/esp_mphal.h index 913bd70dc..194e56f64 100644 --- a/ports/esp8266/esp_mphal.h +++ b/ports/esp8266/esp_mphal.h @@ -72,7 +72,7 @@ void ets_event_poll(void); // C-level pin HAL #include "etshal.h" #include "gpio.h" -#include "esp8266/modmachine.h" +#include "modmachine.h" #define MP_HAL_PIN_FMT "%u" #define mp_hal_pin_obj_t uint32_t #define mp_hal_get_pin_obj(o) mp_obj_get_pin(o) diff --git a/ports/esp8266/modules/ds18x20.py b/ports/esp8266/modules/ds18x20.py index faae59d90..1ec92d1c9 120000 --- a/ports/esp8266/modules/ds18x20.py +++ b/ports/esp8266/modules/ds18x20.py @@ -1 +1 @@ -../../drivers/onewire/ds18x20.py \ No newline at end of file +../../../drivers/onewire/ds18x20.py \ No newline at end of file diff --git a/ports/esp8266/modules/onewire.py b/ports/esp8266/modules/onewire.py index f6ec745e8..33f30e84f 120000 --- a/ports/esp8266/modules/onewire.py +++ b/ports/esp8266/modules/onewire.py @@ -1 +1 @@ -../../drivers/onewire/onewire.py \ No newline at end of file +../../../drivers/onewire/onewire.py \ No newline at end of file diff --git a/ports/esp8266/modules/upip.py b/ports/esp8266/modules/upip.py index 20d52a4ab..130eb6901 120000 --- a/ports/esp8266/modules/upip.py +++ b/ports/esp8266/modules/upip.py @@ -1 +1 @@ -../../tools/upip.py \ No newline at end of file +../../../tools/upip.py \ No newline at end of file diff --git a/ports/esp8266/modules/upip_utarfile.py b/ports/esp8266/modules/upip_utarfile.py index 149886291..d9653d6a6 120000 --- a/ports/esp8266/modules/upip_utarfile.py +++ b/ports/esp8266/modules/upip_utarfile.py @@ -1 +1 @@ -../../tools/upip_utarfile.py \ No newline at end of file +../../../tools/upip_utarfile.py \ No newline at end of file diff --git a/ports/minimal/Makefile b/ports/minimal/Makefile index c95d639af..ae295d655 100644 --- a/ports/minimal/Makefile +++ b/ports/minimal/Makefile @@ -1,4 +1,4 @@ -include ../py/mkenv.mk +include ../../py/mkenv.mk CROSS = 0 diff --git a/ports/pic16bit/Makefile b/ports/pic16bit/Makefile index ebf4fc2e8..970e75d1f 100644 --- a/ports/pic16bit/Makefile +++ b/ports/pic16bit/Makefile @@ -1,4 +1,4 @@ -include ../py/mkenv.mk +include ../../py/mkenv.mk # qstr definitions (must come before including py.mk) QSTR_DEFS = qstrdefsport.h diff --git a/ports/qemu-arm/Makefile b/ports/qemu-arm/Makefile index 71403cb5e..39e13853f 100644 --- a/ports/qemu-arm/Makefile +++ b/ports/qemu-arm/Makefile @@ -1,4 +1,4 @@ -include ../py/mkenv.mk +include ../../py/mkenv.mk -include mpconfigport.mk # qstr definitions (must come before including py.mk) diff --git a/ports/stm32/Makefile b/ports/stm32/Makefile index 58a0a7c7a..913f0913e 100644 --- a/ports/stm32/Makefile +++ b/ports/stm32/Makefile @@ -8,7 +8,7 @@ endif # If the build directory is not given, make it reflect the board name. BUILD ?= build-$(BOARD) -include ../py/mkenv.mk +include ../../py/mkenv.mk -include mpconfigport.mk include boards/$(BOARD)/mpconfigboard.mk @@ -206,7 +206,7 @@ SRC_C = \ timer.c \ led.c \ pin.c \ - pin_defs_stmhal.c \ + pin_defs_stm32.c \ pin_named_pins.c \ bufhelper.c \ dma.c \ diff --git a/ports/stm32/README.md b/ports/stm32/README.md index 32b6d4176..bb184e8db 100644 --- a/ports/stm32/README.md +++ b/ports/stm32/README.md @@ -24,7 +24,7 @@ bytecode. The cross-compiler is built and run on the host machine, using: $ make -C mpy-cross ``` This command should be executed from the root directory of this repository. -All other commands below should be executed from the stmhal/ directory. +All other commands below should be executed from the ports/stm32/ directory. An ARM compiler is required for the build, along with the associated binary utilities. The default compiler is `arm-none-eabi-gcc`, which is available for @@ -71,7 +71,7 @@ Or using `dfu-util` directly: ST Discovery or Nucleo boards have a builtin programmer called ST-LINK. With these boards and using Linux or OS X, you have the option to upload the -`stmhal` firmware using the `st-flash` utility from the +`stm32` firmware using the `st-flash` utility from the [stlink](https://github.com/texane/stlink) project. To do so, connect the board with a mini USB cable to its ST-LINK USB port and then use the make target `deploy-stlink`. For example, if you have the STM32F4DISCOVERY board, you can @@ -101,7 +101,7 @@ a mini USB cable to its ST-LINK USB port and then use the make target $ make BOARD=STM32F4DISC deploy-openocd The `openocd` program, which writes the firmware to the target board's flash, -is configured via the file `stmhal/boards/openocd_stm32f4.cfg`. This +is configured via the file `ports/stm32/boards/openocd_stm32f4.cfg`. This configuration should work for all boards based on a STM32F4xx MCU with a ST-LINKv2 interface. You can override the path to this configuration by setting `OPENOCD_CONFIG` in your Makefile or on the command line. diff --git a/ports/stm32/boards/NUCLEO_F401RE/stm32f4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F401RE/stm32f4xx_hal_conf.h index c20421f0f..a1fd2e083 100644 --- a/ports/stm32/boards/NUCLEO_F401RE/stm32f4xx_hal_conf.h +++ b/ports/stm32/boards/NUCLEO_F401RE/stm32f4xx_hal_conf.h @@ -46,7 +46,7 @@ /* Exported types ------------------------------------------------------------*/ /* Exported constants --------------------------------------------------------*/ -// This board doesn't really have USB, but the stmhal codebase doesn't build +// This board doesn't really have USB, but the stm32 codebase doesn't build // without some USB defined, so we leave this on for now. #define USE_USB_FS diff --git a/ports/stm32/boards/NUCLEO_F411RE/stm32f4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F411RE/stm32f4xx_hal_conf.h index e16fba155..0c424888f 100644 --- a/ports/stm32/boards/NUCLEO_F411RE/stm32f4xx_hal_conf.h +++ b/ports/stm32/boards/NUCLEO_F411RE/stm32f4xx_hal_conf.h @@ -46,7 +46,7 @@ /* Exported types ------------------------------------------------------------*/ /* Exported constants --------------------------------------------------------*/ -// This board doesn't really have USB, but the stmhal codebase doesn't build +// This board doesn't really have USB, but the stm32 codebase doesn't build // without some USB defined, so we leave this on for now. #define USE_USB_FS diff --git a/ports/stm32/boards/NUCLEO_F446RE/stm32f4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F446RE/stm32f4xx_hal_conf.h index 3d0ce926b..487ca009f 100644 --- a/ports/stm32/boards/NUCLEO_F446RE/stm32f4xx_hal_conf.h +++ b/ports/stm32/boards/NUCLEO_F446RE/stm32f4xx_hal_conf.h @@ -46,7 +46,7 @@ /* Exported types ------------------------------------------------------------*/ /* Exported constants --------------------------------------------------------*/ -// This board doesn't really have USB, but the stmhal codebase doesn't build +// This board doesn't really have USB, but the stm32 codebase doesn't build // without some USB defined, so we leave this on for now. #define USE_USB_FS diff --git a/ports/stm32/help.c b/ports/stm32/help.c index 87b2af526..ea0b6921b 100644 --- a/ports/stm32/help.c +++ b/ports/stm32/help.c @@ -26,7 +26,7 @@ #include "py/builtin.h" -const char *stmhal_help_text = +const char *stm32_help_text = "Welcome to MicroPython!\n" "\n" "For online help please visit http://micropython.org/help/.\n" diff --git a/ports/stm32/modules/lcd160cr.py b/ports/stm32/modules/lcd160cr.py index c0e180714..9e63f1d23 120000 --- a/ports/stm32/modules/lcd160cr.py +++ b/ports/stm32/modules/lcd160cr.py @@ -1 +1 @@ -../../drivers/display/lcd160cr.py \ No newline at end of file +../../../drivers/display/lcd160cr.py \ No newline at end of file diff --git a/ports/stm32/modules/lcd160cr_test.py b/ports/stm32/modules/lcd160cr_test.py index 56f091351..5f5bcc128 120000 --- a/ports/stm32/modules/lcd160cr_test.py +++ b/ports/stm32/modules/lcd160cr_test.py @@ -1 +1 @@ -../../drivers/display/lcd160cr_test.py \ No newline at end of file +../../../drivers/display/lcd160cr_test.py \ No newline at end of file diff --git a/ports/stm32/modules/onewire.py b/ports/stm32/modules/onewire.py index f6ec745e8..33f30e84f 120000 --- a/ports/stm32/modules/onewire.py +++ b/ports/stm32/modules/onewire.py @@ -1 +1 @@ -../../drivers/onewire/onewire.py \ No newline at end of file +../../../drivers/onewire/onewire.py \ No newline at end of file diff --git a/ports/stm32/mpconfigport.h b/ports/stm32/mpconfigport.h index 326aa2c20..21142c17b 100644 --- a/ports/stm32/mpconfigport.h +++ b/ports/stm32/mpconfigport.h @@ -92,7 +92,7 @@ #define MICROPY_PY_BUILTINS_INPUT (1) #define MICROPY_PY_BUILTINS_POW3 (1) #define MICROPY_PY_BUILTINS_HELP (1) -#define MICROPY_PY_BUILTINS_HELP_TEXT stmhal_help_text +#define MICROPY_PY_BUILTINS_HELP_TEXT stm32_help_text #define MICROPY_PY_BUILTINS_HELP_MODULES (1) #define MICROPY_PY_MICROPYTHON_MEM_INFO (1) #define MICROPY_PY_ARRAY_SLICE_ASSIGN (1) @@ -345,4 +345,4 @@ static inline mp_uint_t disable_irq(void) { // We need to provide a declaration/definition of alloca() #include -#define MICROPY_PIN_DEFS_PORT_H "pin_defs_stmhal.h" +#define MICROPY_PIN_DEFS_PORT_H "pin_defs_stm32.h" diff --git a/ports/stm32/mphalport.h b/ports/stm32/mphalport.h index 8dd95c470..939df0b3d 100644 --- a/ports/stm32/mphalport.h +++ b/ports/stm32/mphalport.h @@ -27,7 +27,7 @@ void mp_hal_set_interrupt_char(int c); // -1 to disable // timing functions -#include "stmhal/irq.h" +#include "irq.h" #define mp_hal_quiet_timing_enter() raise_irq_pri(1) #define mp_hal_quiet_timing_exit(irq_state) restore_irq_pri(irq_state) @@ -44,7 +44,7 @@ static inline mp_uint_t mp_hal_ticks_cpu(void) { // C-level pin HAL -#include "stmhal/pin.h" +#include "pin.h" #define MP_HAL_PIN_FMT "%q" #define MP_HAL_PIN_MODE_INPUT (0) diff --git a/ports/stm32/pin_defs_stm32.c b/ports/stm32/pin_defs_stm32.c new file mode 100644 index 000000000..0aef5f95f --- /dev/null +++ b/ports/stm32/pin_defs_stm32.c @@ -0,0 +1,31 @@ +#include "py/obj.h" +#include "pin.h" + +// Returns the pin mode. This value returned by this macro should be one of: +// GPIO_MODE_INPUT, GPIO_MODE_OUTPUT_PP, GPIO_MODE_OUTPUT_OD, +// GPIO_MODE_AF_PP, GPIO_MODE_AF_OD, or GPIO_MODE_ANALOG. + +uint32_t pin_get_mode(const pin_obj_t *pin) { + GPIO_TypeDef *gpio = pin->gpio; + uint32_t mode = (gpio->MODER >> (pin->pin * 2)) & 3; + if (mode != GPIO_MODE_ANALOG) { + if (gpio->OTYPER & pin->pin_mask) { + mode |= 1 << 4; + } + } + return mode; +} + +// Returns the pin pullup/pulldown. The value returned by this macro should +// be one of GPIO_NOPULL, GPIO_PULLUP, or GPIO_PULLDOWN. + +uint32_t pin_get_pull(const pin_obj_t *pin) { + return (pin->gpio->PUPDR >> (pin->pin * 2)) & 3; +} + +// Returns the af (alternate function) index currently set for a pin. + +uint32_t pin_get_af(const pin_obj_t *pin) { + return (pin->gpio->AFR[pin->pin >> 3] >> ((pin->pin & 7) * 4)) & 0xf; +} + diff --git a/ports/stm32/pin_defs_stm32.h b/ports/stm32/pin_defs_stm32.h new file mode 100644 index 000000000..c5b286283 --- /dev/null +++ b/ports/stm32/pin_defs_stm32.h @@ -0,0 +1,131 @@ +/* + * This file is part of the MicroPython project, http://micropython.org/ + * + * The MIT License (MIT) + * + * Copyright (c) 2013, 2014 Damien P. George + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +// This file contains pin definitions that are specific to the stm32 port. +// This file should only ever be #included by pin.h and not directly. + +enum { + PORT_A, + PORT_B, + PORT_C, + PORT_D, + PORT_E, + PORT_F, + PORT_G, + PORT_H, + PORT_I, + PORT_J, + PORT_K, +}; + +enum { + AF_FN_TIM, + AF_FN_I2C, + AF_FN_USART, + AF_FN_UART = AF_FN_USART, + AF_FN_SPI, + AF_FN_I2S, + AF_FN_SDMMC, +}; + +enum { + AF_PIN_TYPE_TIM_CH1 = 0, + AF_PIN_TYPE_TIM_CH2, + AF_PIN_TYPE_TIM_CH3, + AF_PIN_TYPE_TIM_CH4, + AF_PIN_TYPE_TIM_CH1N, + AF_PIN_TYPE_TIM_CH2N, + AF_PIN_TYPE_TIM_CH3N, + AF_PIN_TYPE_TIM_CH1_ETR, + AF_PIN_TYPE_TIM_ETR, + AF_PIN_TYPE_TIM_BKIN, + + AF_PIN_TYPE_I2C_SDA = 0, + AF_PIN_TYPE_I2C_SCL, + + AF_PIN_TYPE_USART_TX = 0, + AF_PIN_TYPE_USART_RX, + AF_PIN_TYPE_USART_CTS, + AF_PIN_TYPE_USART_RTS, + AF_PIN_TYPE_USART_CK, + AF_PIN_TYPE_UART_TX = AF_PIN_TYPE_USART_TX, + AF_PIN_TYPE_UART_RX = AF_PIN_TYPE_USART_RX, + AF_PIN_TYPE_UART_CTS = AF_PIN_TYPE_USART_CTS, + AF_PIN_TYPE_UART_RTS = AF_PIN_TYPE_USART_RTS, + + AF_PIN_TYPE_SPI_MOSI = 0, + AF_PIN_TYPE_SPI_MISO, + AF_PIN_TYPE_SPI_SCK, + AF_PIN_TYPE_SPI_NSS, + + AF_PIN_TYPE_I2S_CK = 0, + AF_PIN_TYPE_I2S_MCK, + AF_PIN_TYPE_I2S_SD, + AF_PIN_TYPE_I2S_WS, + AF_PIN_TYPE_I2S_EXTSD, + + AF_PIN_TYPE_SDMMC_CK = 0, + AF_PIN_TYPE_SDMMC_CMD, + AF_PIN_TYPE_SDMMC_D0, + AF_PIN_TYPE_SDMMC_D1, + AF_PIN_TYPE_SDMMC_D2, + AF_PIN_TYPE_SDMMC_D3, +}; + +// The HAL uses a slightly different naming than we chose, so we provide +// some #defines to massage things. Also I2S and SPI share the same +// peripheral. + +#define GPIO_AF5_I2S2 GPIO_AF5_SPI2 +#define GPIO_AF5_I2S3 GPIO_AF5_I2S3ext +#define GPIO_AF6_I2S2 GPIO_AF6_I2S2ext +#define GPIO_AF6_I2S3 GPIO_AF6_SPI3 +#define GPIO_AF7_I2S2 GPIO_AF7_SPI2 +#define GPIO_AF7_I2S3 GPIO_AF7_I2S3ext + +#define I2S2 SPI2 +#define I2S3 SPI3 + +enum { + PIN_ADC1 = (1 << 0), + PIN_ADC2 = (1 << 1), + PIN_ADC3 = (1 << 2), +}; + +// Note that SPI and I2S are really the same peripheral as far as the HAL +// is concerned, so there is no I2S_TypeDef. +// We use void* for SDMMC because not all MCUs have the SDMMC_TypeDef type. +#define PIN_DEFS_PORT_AF_UNION \ + TIM_TypeDef *TIM; \ + I2C_TypeDef *I2C; \ + USART_TypeDef *USART; \ + USART_TypeDef *UART; \ + SPI_TypeDef *SPI;\ + SPI_TypeDef *I2S; \ + void *SDMMC; \ + +typedef GPIO_TypeDef pin_gpio_t; + diff --git a/ports/stm32/pin_defs_stmhal.c b/ports/stm32/pin_defs_stmhal.c deleted file mode 100644 index 0aef5f95f..000000000 --- a/ports/stm32/pin_defs_stmhal.c +++ /dev/null @@ -1,31 +0,0 @@ -#include "py/obj.h" -#include "pin.h" - -// Returns the pin mode. This value returned by this macro should be one of: -// GPIO_MODE_INPUT, GPIO_MODE_OUTPUT_PP, GPIO_MODE_OUTPUT_OD, -// GPIO_MODE_AF_PP, GPIO_MODE_AF_OD, or GPIO_MODE_ANALOG. - -uint32_t pin_get_mode(const pin_obj_t *pin) { - GPIO_TypeDef *gpio = pin->gpio; - uint32_t mode = (gpio->MODER >> (pin->pin * 2)) & 3; - if (mode != GPIO_MODE_ANALOG) { - if (gpio->OTYPER & pin->pin_mask) { - mode |= 1 << 4; - } - } - return mode; -} - -// Returns the pin pullup/pulldown. The value returned by this macro should -// be one of GPIO_NOPULL, GPIO_PULLUP, or GPIO_PULLDOWN. - -uint32_t pin_get_pull(const pin_obj_t *pin) { - return (pin->gpio->PUPDR >> (pin->pin * 2)) & 3; -} - -// Returns the af (alternate function) index currently set for a pin. - -uint32_t pin_get_af(const pin_obj_t *pin) { - return (pin->gpio->AFR[pin->pin >> 3] >> ((pin->pin & 7) * 4)) & 0xf; -} - diff --git a/ports/stm32/pin_defs_stmhal.h b/ports/stm32/pin_defs_stmhal.h deleted file mode 100644 index 6cf3b1b83..000000000 --- a/ports/stm32/pin_defs_stmhal.h +++ /dev/null @@ -1,131 +0,0 @@ -/* - * This file is part of the MicroPython project, http://micropython.org/ - * - * The MIT License (MIT) - * - * Copyright (c) 2013, 2014 Damien P. George - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ - -// This file contains pin definitions that are specific to the stmhal port. -// This file should only ever be #included by pin.h and not directly. - -enum { - PORT_A, - PORT_B, - PORT_C, - PORT_D, - PORT_E, - PORT_F, - PORT_G, - PORT_H, - PORT_I, - PORT_J, - PORT_K, -}; - -enum { - AF_FN_TIM, - AF_FN_I2C, - AF_FN_USART, - AF_FN_UART = AF_FN_USART, - AF_FN_SPI, - AF_FN_I2S, - AF_FN_SDMMC, -}; - -enum { - AF_PIN_TYPE_TIM_CH1 = 0, - AF_PIN_TYPE_TIM_CH2, - AF_PIN_TYPE_TIM_CH3, - AF_PIN_TYPE_TIM_CH4, - AF_PIN_TYPE_TIM_CH1N, - AF_PIN_TYPE_TIM_CH2N, - AF_PIN_TYPE_TIM_CH3N, - AF_PIN_TYPE_TIM_CH1_ETR, - AF_PIN_TYPE_TIM_ETR, - AF_PIN_TYPE_TIM_BKIN, - - AF_PIN_TYPE_I2C_SDA = 0, - AF_PIN_TYPE_I2C_SCL, - - AF_PIN_TYPE_USART_TX = 0, - AF_PIN_TYPE_USART_RX, - AF_PIN_TYPE_USART_CTS, - AF_PIN_TYPE_USART_RTS, - AF_PIN_TYPE_USART_CK, - AF_PIN_TYPE_UART_TX = AF_PIN_TYPE_USART_TX, - AF_PIN_TYPE_UART_RX = AF_PIN_TYPE_USART_RX, - AF_PIN_TYPE_UART_CTS = AF_PIN_TYPE_USART_CTS, - AF_PIN_TYPE_UART_RTS = AF_PIN_TYPE_USART_RTS, - - AF_PIN_TYPE_SPI_MOSI = 0, - AF_PIN_TYPE_SPI_MISO, - AF_PIN_TYPE_SPI_SCK, - AF_PIN_TYPE_SPI_NSS, - - AF_PIN_TYPE_I2S_CK = 0, - AF_PIN_TYPE_I2S_MCK, - AF_PIN_TYPE_I2S_SD, - AF_PIN_TYPE_I2S_WS, - AF_PIN_TYPE_I2S_EXTSD, - - AF_PIN_TYPE_SDMMC_CK = 0, - AF_PIN_TYPE_SDMMC_CMD, - AF_PIN_TYPE_SDMMC_D0, - AF_PIN_TYPE_SDMMC_D1, - AF_PIN_TYPE_SDMMC_D2, - AF_PIN_TYPE_SDMMC_D3, -}; - -// The HAL uses a slightly different naming than we chose, so we provide -// some #defines to massage things. Also I2S and SPI share the same -// peripheral. - -#define GPIO_AF5_I2S2 GPIO_AF5_SPI2 -#define GPIO_AF5_I2S3 GPIO_AF5_I2S3ext -#define GPIO_AF6_I2S2 GPIO_AF6_I2S2ext -#define GPIO_AF6_I2S3 GPIO_AF6_SPI3 -#define GPIO_AF7_I2S2 GPIO_AF7_SPI2 -#define GPIO_AF7_I2S3 GPIO_AF7_I2S3ext - -#define I2S2 SPI2 -#define I2S3 SPI3 - -enum { - PIN_ADC1 = (1 << 0), - PIN_ADC2 = (1 << 1), - PIN_ADC3 = (1 << 2), -}; - -// Note that SPI and I2S are really the same peripheral as far as the HAL -// is concerned, so there is no I2S_TypeDef. -// We use void* for SDMMC because not all MCUs have the SDMMC_TypeDef type. -#define PIN_DEFS_PORT_AF_UNION \ - TIM_TypeDef *TIM; \ - I2C_TypeDef *I2C; \ - USART_TypeDef *USART; \ - USART_TypeDef *UART; \ - SPI_TypeDef *SPI;\ - SPI_TypeDef *I2S; \ - void *SDMMC; \ - -typedef GPIO_TypeDef pin_gpio_t; - diff --git a/ports/teensy/Makefile b/ports/teensy/Makefile index 944e281a4..08ecf0f91 100644 --- a/ports/teensy/Makefile +++ b/ports/teensy/Makefile @@ -1,4 +1,4 @@ -include ../py/mkenv.mk +include ../../py/mkenv.mk # qstr definitions (must come before including py.mk) QSTR_DEFS = qstrdefsport.h $(BUILD)/pins_qstr.h @@ -31,7 +31,7 @@ CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -mcpu=cortex-m4 -msoft-float -mfloat INC += -I. INC += -I$(TOP) -INC += -I$(TOP)/stmhal +INC += -I$(TOP)/ports/stm32 INC += -I$(BUILD) INC += -Icore @@ -91,14 +91,14 @@ SRC_C = \ uart.c \ usb.c \ -STM_SRC_C = $(addprefix stmhal/,\ +STM_SRC_C = $(addprefix ports/stm32/,\ gccollect.c \ irq.c \ pin.c \ pin_named_pins.c \ ) -STM_SRC_S = $(addprefix stmhal/,\ +STM_SRC_S = $(addprefix ports/stm32/,\ gchelper.s \ ) diff --git a/ports/teensy/lcd.c b/ports/teensy/lcd.c index e79b7d5ac..e5d6115d7 100644 --- a/ports/teensy/lcd.c +++ b/ports/teensy/lcd.c @@ -1,5 +1,5 @@ #include "py/obj.h" -#include "../stmhal/lcd.h" +#include "../stm32/lcd.h" void lcd_init(void) { } diff --git a/ports/unix/Makefile b/ports/unix/Makefile index 08bd4db30..1a1ea01f7 100644 --- a/ports/unix/Makefile +++ b/ports/unix/Makefile @@ -1,5 +1,5 @@ -include mpconfigport.mk -include ../py/mkenv.mk +include ../../py/mkenv.mk FROZEN_DIR = scripts FROZEN_MPY_DIR = modules @@ -188,7 +188,7 @@ include $(TOP)/py/mkrules.mk .PHONY: test test: $(PROG) $(TOP)/tests/run-tests - $(eval DIRNAME=$(notdir $(CURDIR))) + $(eval DIRNAME=ports/$(notdir $(CURDIR))) cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/$(PROG) ./run-tests # install micropython in /usr/local/bin @@ -253,7 +253,7 @@ coverage: BUILD=build-coverage PROG=micropython_coverage coverage_test: coverage - $(eval DIRNAME=$(notdir $(CURDIR))) + $(eval DIRNAME=ports/$(notdir $(CURDIR))) cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/micropython_coverage ./run-tests cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/micropython_coverage ./run-tests -d thread cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/micropython_coverage ./run-tests --emit native diff --git a/ports/unix/modules/upip.py b/ports/unix/modules/upip.py index 20d52a4ab..130eb6901 120000 --- a/ports/unix/modules/upip.py +++ b/ports/unix/modules/upip.py @@ -1 +1 @@ -../../tools/upip.py \ No newline at end of file +../../../tools/upip.py \ No newline at end of file diff --git a/ports/unix/modules/upip_utarfile.py b/ports/unix/modules/upip_utarfile.py index 149886291..d9653d6a6 120000 --- a/ports/unix/modules/upip_utarfile.py +++ b/ports/unix/modules/upip_utarfile.py @@ -1 +1 @@ -../../tools/upip_utarfile.py \ No newline at end of file +../../../tools/upip_utarfile.py \ No newline at end of file diff --git a/ports/windows/.appveyor.yml b/ports/windows/.appveyor.yml index 84060a116..a82cf5adc 100644 --- a/ports/windows/.appveyor.yml +++ b/ports/windows/.appveyor.yml @@ -15,7 +15,7 @@ platform: - x64 build: - project: windows/micropython.vcxproj + project: ports/windows/micropython.vcxproj verbosity: normal test_script: diff --git a/ports/windows/Makefile b/ports/windows/Makefile index a39d34826..b6433300f 100644 --- a/ports/windows/Makefile +++ b/ports/windows/Makefile @@ -1,4 +1,4 @@ -include ../py/mkenv.mk +include ../../py/mkenv.mk -include mpconfigport.mk # define main target @@ -28,13 +28,13 @@ endif # source files SRC_C = \ - unix/main.c \ - unix/file.c \ - unix/input.c \ - unix/modos.c \ - unix/modmachine.c \ - unix/modtime.c \ - unix/gccollect.c \ + ports/unix/main.c \ + ports/unix/file.c \ + ports/unix/input.c \ + ports/unix/modos.c \ + ports/unix/modmachine.c \ + ports/unix/modtime.c \ + ports/unix/gccollect.c \ windows_mphal.c \ realpath.c \ init.c \ diff --git a/ports/windows/README.md b/ports/windows/README.md index 6d3249903..f1bd40551 100644 --- a/ports/windows/README.md +++ b/ports/windows/README.md @@ -50,8 +50,8 @@ __Stack usage__ The msvc compiler is quite stack-hungry which might result in a "maximum recursion depth exceeded" RuntimeError for code with lots of nested function calls. There are several ways to deal with this: -- increase the threshold used for detection by altering the argument to `mp_stack_set_limit` in `unix/main.c` -- disable detection all together by setting `MICROPY_STACK_CHECK` to "0" in `windows/mpconfigport.h` +- increase the threshold used for detection by altering the argument to `mp_stack_set_limit` in `ports/unix/main.c` +- disable detection all together by setting `MICROPY_STACK_CHECK` to "0" in `ports/windows/mpconfigport.h` - disable the /GL compiler flag by setting `WholeProgramOptimization` to "false" See [issue 2927](https://github.com/micropython/micropython/issues/2927) for more information. diff --git a/ports/windows/msvc/genhdr.targets b/ports/windows/msvc/genhdr.targets index cac3e3ddc..ee030c906 100644 --- a/ports/windows/msvc/genhdr.targets +++ b/ports/windows/msvc/genhdr.targets @@ -10,7 +10,7 @@ $(PyBuildDir)genhdr\ $(PyBaseDir)py\ - $(PyBaseDir)unix\qstrdefsport.h + $(PyBaseDir)ports\unix\qstrdefsport.h $(PySrcDir)qstrdefs.h $(DestDir)qstrdefscollected.h $(DestDir)qstrdefs.generated.h diff --git a/ports/windows/msvc/paths.props b/ports/windows/msvc/paths.props index 716698243..db3af4c0f 100644 --- a/ports/windows/msvc/paths.props +++ b/ports/windows/msvc/paths.props @@ -3,28 +3,28 @@ True - - $([System.IO.Path]::GetFullPath(`$(MSBuildThisFileDirectory)..\..`))\ - $(PyBaseDir)windows\ + $([System.IO.Path]::GetFullPath(`$(MSBuildThisFileDirectory)..\..\..`))\ + $(PyBaseDir)ports\windows\ $(PyWinDir)build\ diff --git a/ports/windows/msvc/sources.props b/ports/windows/msvc/sources.props index a97686cdc..b85295ebc 100644 --- a/ports/windows/msvc/sources.props +++ b/ports/windows/msvc/sources.props @@ -3,16 +3,16 @@ - - + + - - - - - - - + + + + + + + @@ -31,7 +31,7 @@ - - + + diff --git a/ports/windows/windows_mphal.h b/ports/windows/windows_mphal.h index 5a93d4e18..2b7aab44a 100644 --- a/ports/windows/windows_mphal.h +++ b/ports/windows/windows_mphal.h @@ -25,7 +25,7 @@ */ #include "sleep.h" -#include "unix/mphalport.h" +#include "ports/unix/mphalport.h" #define MICROPY_HAL_HAS_VT100 (0) diff --git a/ports/zephyr/Makefile b/ports/zephyr/Makefile index 5840cc47e..8b7cb76c3 100644 --- a/ports/zephyr/Makefile +++ b/ports/zephyr/Makefile @@ -26,7 +26,7 @@ ifneq ($(MAKECMDGOALS), clean) include $(Z_EXPORTS) endif -include ../py/mkenv.mk +include ../../py/mkenv.mk include $(TOP)/py/py.mk INC += -I. diff --git a/py/mkrules.mk b/py/mkrules.mk index bf6ad2941..13545eb6f 100644 --- a/py/mkrules.mk +++ b/py/mkrules.mk @@ -103,7 +103,7 @@ endif ifneq ($(FROZEN_MPY_DIR),) # to build the MicroPython cross compiler -$(TOP)/mpy-cross/mpy-cross: $(TOP)/py/*.[ch] $(TOP)/mpy-cross/*.[ch] $(TOP)/windows/fmode.c +$(TOP)/mpy-cross/mpy-cross: $(TOP)/py/*.[ch] $(TOP)/mpy-cross/*.[ch] $(TOP)/ports/windows/fmode.c $(Q)$(MAKE) -C $(TOP)/mpy-cross # make a list of all the .py files that need compiling and freezing diff --git a/tests/run-tests b/tests/run-tests index f9c26283d..14df1e986 100755 --- a/tests/run-tests +++ b/tests/run-tests @@ -13,10 +13,10 @@ from glob import glob # to the correct executable. if os.name == 'nt': CPYTHON3 = os.getenv('MICROPY_CPYTHON3', 'python3.exe') - MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../windows/micropython.exe') + MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../ports/windows/micropython.exe') else: CPYTHON3 = os.getenv('MICROPY_CPYTHON3', 'python3') - MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../unix/micropython') + MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../ports/unix/micropython') # mpy-cross is only needed if --via-mpy command-line arg is passed MPYCROSS = os.getenv('MICROPY_MPYCROSS', '../mpy-cross/mpy-cross') diff --git a/tools/check_code_size.sh b/tools/check_code_size.sh index c5f0c6ffd..2925ff168 100755 --- a/tools/check_code_size.sh +++ b/tools/check_code_size.sh @@ -10,7 +10,7 @@ REFERENCE=$HOME/persist/firmware.bin if [ -f $REFERENCE ]; then size_old=$(stat -c%s $REFERENCE) - size_new=$(stat -c%s minimal/build/firmware.bin) + size_new=$(stat -c%s ports/minimal/build/firmware.bin) echo "Old size: $size_old new size: $size_new" if [ $size_new -gt $size_old ]; then echo "Validation failure: Core code size increased" diff --git a/tools/codestats.sh b/tools/codestats.sh index 5272f3e9c..09284a30d 100755 --- a/tools/codestats.sh +++ b/tools/codestats.sh @@ -9,7 +9,7 @@ # executing because it does not exist in old revisions of the repository. # check that we are in the root directory of the repository -if [ ! -d py -o ! -d unix -o ! -d stmhal ]; then +if [ ! -d py -o ! -d ports/unix -o ! -d ports/stm32 ]; then echo "script must be run from root of the repository" exit 1 fi @@ -23,18 +23,18 @@ AWK=awk MAKE="make -j2" # these are the binaries that are built; some have 2 or 3 depending on version -bin_unix=unix/micropython -bin_stmhal=stmhal/build-PYBV10/firmware.elf -bin_barearm_1=bare-arm/build/flash.elf -bin_barearm_2=bare-arm/build/firmware.elf -bin_minimal=minimal/build/firmware.elf -bin_cc3200_1=cc3200/build/LAUNCHXL/application.axf -bin_cc3200_2=cc3200/build/LAUNCHXL/release/application.axf -bin_cc3200_3=cc3200/build/WIPY/release/application.axf +bin_unix=ports/unix/micropython +bin_stm32=ports/stm32/build-PYBV10/firmware.elf +bin_barearm_1=ports/bare-arm/build/flash.elf +bin_barearm_2=ports/bare-arm/build/firmware.elf +bin_minimal=ports/minimal/build/firmware.elf +bin_cc3200_1=ports/cc3200/build/LAUNCHXL/application.axf +bin_cc3200_2=ports/cc3200/build/LAUNCHXL/release/application.axf +bin_cc3200_3=ports/cc3200/build/WIPY/release/application.axf # start at zero size; if build fails reuse previous valid size size_unix="0" -size_stmhal="0" +size_stm32="0" size_barearm="0" size_minimal="0" size_cc3200="0" @@ -86,7 +86,7 @@ function get_size3() { if [ -r $output ]; then last_rev=$(tail -n1 $output | $AWK '{print $1}') else - echo "# hash size_unix size_stmhal size_barearm size_minimal size_cc3200 pystones" > $output + echo "# hash size_unix size_stm32 size_barearm size_minimal size_cc3200 pystones" > $output last_rev="v1.0" fi @@ -132,37 +132,37 @@ EOF #### unix #### $RM $bin_unix - $MAKE -C unix CFLAGS_EXTRA=-DNDEBUG + $MAKE -C ports/unix CFLAGS_EXTRA=-DNDEBUG size_unix=$(get_size $size_unix $bin_unix) # undo patch if it was applied git checkout unix/modtime.c - #### stmhal #### + #### stm32 #### - $RM $bin_stmhal - $MAKE -C stmhal board=PYBV10 - size_stmhal=$(get_size $size_stmhal $bin_stmhal) + $RM $bin_stm32 + $MAKE -C ports/stm32 board=PYBV10 + size_stm32=$(get_size $size_stm32 $bin_stm32) #### bare-arm #### $RM $bin_barearm_1 $bin_barearm_2 - $MAKE -C bare-arm + $MAKE -C ports/bare-arm size_barearm=$(get_size2 $size_barearm $bin_barearm_1 $bin_barearm_2) #### minimal #### - if [ -r minimal/Makefile ]; then + if [ -r ports/minimal/Makefile ]; then $RM $bin_minimal - $MAKE -C minimal CROSS=1 + $MAKE -C ports/minimal CROSS=1 size_minimal=$(get_size $size_minimal $bin_minimal) fi #### cc3200 #### - if [ -r cc3200/Makefile ]; then + if [ -r ports/cc3200/Makefile ]; then $RM $bin_cc3200_1 $bin_cc3200_2 $bin_cc3200_3 - $MAKE -C cc3200 BTARGET=application + $MAKE -C ports/cc3200 BTARGET=application size_cc3200=$(get_size3 $size_cc3200 $bin_cc3200_1 $bin_cc3200_2 $bin_cc3200_3) fi @@ -178,7 +178,7 @@ EOF #### output data for this commit #### - echo "$hash $size_unix $size_stmhal $size_barearm $size_minimal $size_cc3200 $pystones" >> $output + echo "$hash $size_unix $size_stm32 $size_barearm $size_minimal $size_cc3200 $pystones" >> $output done -- cgit v1.2.3 From 68c28174d0e0ec3f6b1461aea3a0b6a1b84610bb Mon Sep 17 00:00:00 2001 From: tll <1040424979@qq.com> Date: Sat, 24 Jun 2017 08:38:32 +0800 Subject: py/objstr: Add check for valid UTF-8 when making a str from bytes. This patch adds a function utf8_check() to check for a valid UTF-8 encoded string, and calls it when constructing a str from raw bytes. The feature is selectable at compile time via MICROPY_PY_BUILTINS_STR_UNICODE_CHECK and is enabled if unicode is enabled. It costs about 110 bytes on Thumb-2, 150 bytes on Xtensa and 170 bytes on x86-64. --- py/mpconfig.h | 5 +++++ py/objstr.c | 10 ++++++++++ py/unicode.c | 28 ++++++++++++++++++++++++++++ py/unicode.h | 1 + tests/unicode/unicode.py | 14 ++++++++++++++ 5 files changed, 58 insertions(+) (limited to 'tests') diff --git a/py/mpconfig.h b/py/mpconfig.h index dac8a903c..38cf4b560 100644 --- a/py/mpconfig.h +++ b/py/mpconfig.h @@ -691,6 +691,11 @@ typedef double mp_float_t; #define MICROPY_PY_BUILTINS_STR_UNICODE (0) #endif +// Whether to check for valid UTF-8 when converting bytes to str +#ifndef MICROPY_PY_BUILTINS_STR_UNICODE_CHECK +#define MICROPY_PY_BUILTINS_STR_UNICODE_CHECK (MICROPY_PY_BUILTINS_STR_UNICODE) +#endif + // Whether str.center() method provided #ifndef MICROPY_PY_BUILTINS_STR_CENTER #define MICROPY_PY_BUILTINS_STR_CENTER (0) diff --git a/py/objstr.c b/py/objstr.c index 4c287af04..f6214f80c 100644 --- a/py/objstr.c +++ b/py/objstr.c @@ -161,6 +161,11 @@ mp_obj_t mp_obj_str_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_ if (str_hash == 0) { str_hash = qstr_compute_hash(str_data, str_len); } + #if MICROPY_PY_BUILTINS_STR_UNICODE_CHECK + if (!utf8_check(str_data, str_len)) { + mp_raise_msg(&mp_type_UnicodeError, NULL); + } + #endif mp_obj_str_t *o = MP_OBJ_TO_PTR(mp_obj_new_str_of_type(type, NULL, str_len)); o->data = str_data; o->hash = str_hash; @@ -168,6 +173,11 @@ mp_obj_t mp_obj_str_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_ } else { mp_buffer_info_t bufinfo; mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_READ); + #if MICROPY_PY_BUILTINS_STR_UNICODE_CHECK + if (!utf8_check(bufinfo.buf, bufinfo.len)) { + mp_raise_msg(&mp_type_UnicodeError, NULL); + } + #endif return mp_obj_new_str(bufinfo.buf, bufinfo.len, false); } } diff --git a/py/unicode.c b/py/unicode.c index eddb007d5..140b7ba71 100644 --- a/py/unicode.c +++ b/py/unicode.c @@ -182,3 +182,31 @@ mp_uint_t unichar_xdigit_value(unichar c) { } return n; } + +bool utf8_check(const byte *p, size_t len) { + uint8_t need = 0; + const byte *end = p + len; + for (; p < end; p++) { + byte c = *p; + if (need) { + if (c >= 0x80) { + need--; + } else { + // mismatch + return 0; + } + } else { + if (c >= 0xc0) { + if (c >= 0xf8) { + // mismatch + return 0; + } + need = (0xe5 >> ((c >> 3) & 0x6)) & 3; + } else if (c >= 0x80) { + // mismatch + return 0; + } + } + } + return need == 0; // no pending fragments allowed +} diff --git a/py/unicode.h b/py/unicode.h index 19487a65a..c1fb51789 100644 --- a/py/unicode.h +++ b/py/unicode.h @@ -30,5 +30,6 @@ #include "py/misc.h" mp_uint_t utf8_ptr_to_index(const byte *s, const byte *ptr); +bool utf8_check(const byte *p, size_t len); #endif // MICROPY_INCLUDED_PY_UNICODE_H diff --git a/tests/unicode/unicode.py b/tests/unicode/unicode.py index 5f29bc1c9..3a35ce894 100644 --- a/tests/unicode/unicode.py +++ b/tests/unicode/unicode.py @@ -33,3 +33,17 @@ try: int('\u0200') except ValueError: print('ValueError') + +# test invalid UTF-8 string +try: + str(b'ab\xa1', 'utf8') +except UnicodeError: + print('UnicodeError') +try: + str(b'ab\xf8', 'utf8') +except UnicodeError: + print('UnicodeError') +try: + str(bytearray(b'ab\xc0a'), 'utf8') +except UnicodeError: + print('UnicodeError') -- cgit v1.2.3 From 5c603bd0fd53e7dbd709883f289d1e580c86e33d Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Thu, 7 Sep 2017 00:10:10 +0300 Subject: py/objlist: Properly implement comparison with incompatible types. Should raise TypeError, unless it's (in)equality comparison. --- py/objlist.c | 26 ++++++++++++-------------- tests/basics/list_compare.py | 10 ++++++++++ 2 files changed, 22 insertions(+), 14 deletions(-) (limited to 'tests') diff --git a/py/objlist.c b/py/objlist.c index 6ac33e80e..d70867ded 100644 --- a/py/objlist.c +++ b/py/objlist.c @@ -87,18 +87,6 @@ STATIC mp_obj_t list_make_new(const mp_obj_type_t *type_in, size_t n_args, size_ } } -// Don't pass MP_BINARY_OP_NOT_EQUAL here -STATIC bool list_cmp_helper(mp_uint_t op, mp_obj_t self_in, mp_obj_t another_in) { - mp_check_self(MP_OBJ_IS_TYPE(self_in, &mp_type_list)); - if (!MP_OBJ_IS_TYPE(another_in, &mp_type_list)) { - return false; - } - mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in); - mp_obj_list_t *another = MP_OBJ_TO_PTR(another_in); - - return mp_seq_cmp_objs(op, self->items, self->len, another->items, another->len); -} - STATIC mp_obj_t list_unary_op(mp_unary_op_t op, mp_obj_t self_in) { mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in); switch (op) { @@ -146,8 +134,18 @@ STATIC mp_obj_t list_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) { case MP_BINARY_OP_LESS: case MP_BINARY_OP_LESS_EQUAL: case MP_BINARY_OP_MORE: - case MP_BINARY_OP_MORE_EQUAL: - return mp_obj_new_bool(list_cmp_helper(op, lhs, rhs)); + case MP_BINARY_OP_MORE_EQUAL: { + if (!MP_OBJ_IS_TYPE(rhs, &mp_type_list)) { + if (op == MP_BINARY_OP_EQUAL) { + return mp_const_false; + } + return MP_OBJ_NULL; // op not supported + } + + mp_obj_list_t *another = MP_OBJ_TO_PTR(rhs); + bool res = mp_seq_cmp_objs(op, o->items, o->len, another->items, another->len); + return mp_obj_new_bool(res); + } default: return MP_OBJ_NULL; // op not supported diff --git a/tests/basics/list_compare.py b/tests/basics/list_compare.py index eea881424..fd656c7f1 100644 --- a/tests/basics/list_compare.py +++ b/tests/basics/list_compare.py @@ -48,3 +48,13 @@ print([1] <= [1, 0]) print([1] <= [1, -1]) print([1, 0] <= [1]) print([1, -1] <= [1]) + + +print([] == {}) +print([] != {}) +print([1] == (1,)) + +try: + print([] < {}) +except TypeError: + print("TypeError") -- cgit v1.2.3 From d4d1c45a553c6361a72053383f0fe242f05cad3d Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Thu, 7 Sep 2017 10:55:43 +0300 Subject: py/runtime0.h: Move relational ops to the beginning of mp_binary_op_t. This is to allow to encode arithmetic operations more efficiently, in preparation to introduction of __rOP__ method support. --- py/objint_mpz.c | 2 +- py/runtime0.h | 31 ++++++++++++++++--------------- tests/cmdline/cmd_showbc.py.exp | 22 +++++++++++----------- 3 files changed, 28 insertions(+), 27 deletions(-) (limited to 'tests') diff --git a/py/objint_mpz.c b/py/objint_mpz.c index 148446f0f..c7a3074ba 100644 --- a/py/objint_mpz.c +++ b/py/objint_mpz.c @@ -221,7 +221,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i return mp_obj_new_float(flhs / frhs); #endif - } else if (op <= MP_BINARY_OP_INPLACE_POWER) { + } else if (op >= MP_BINARY_OP_OR) { mp_obj_int_t *res = mp_obj_int_new_mpz(); switch (op) { diff --git a/py/runtime0.h b/py/runtime0.h index 703c950f2..074dac1e4 100644 --- a/py/runtime0.h +++ b/py/runtime0.h @@ -54,6 +54,22 @@ typedef enum { } mp_unary_op_t; typedef enum { + // Relational operations, should return a bool + MP_BINARY_OP_LESS, + MP_BINARY_OP_MORE, + MP_BINARY_OP_EQUAL, + MP_BINARY_OP_LESS_EQUAL, + MP_BINARY_OP_MORE_EQUAL, + + MP_BINARY_OP_NOT_EQUAL, + MP_BINARY_OP_IN, + MP_BINARY_OP_IS, + MP_BINARY_OP_EXCEPTION_MATCH, + // these are not supported by the runtime and must be synthesised by the emitter + MP_BINARY_OP_NOT_IN, + MP_BINARY_OP_IS_NOT, + + // Arithmetic operations MP_BINARY_OP_OR, MP_BINARY_OP_XOR, MP_BINARY_OP_AND, @@ -83,21 +99,6 @@ typedef enum { MP_BINARY_OP_INPLACE_TRUE_DIVIDE, MP_BINARY_OP_INPLACE_MODULO, MP_BINARY_OP_INPLACE_POWER, - - // these should return a bool - MP_BINARY_OP_LESS, - MP_BINARY_OP_MORE, - MP_BINARY_OP_EQUAL, - MP_BINARY_OP_LESS_EQUAL, - MP_BINARY_OP_MORE_EQUAL, - - MP_BINARY_OP_NOT_EQUAL, - MP_BINARY_OP_IN, - MP_BINARY_OP_IS, - MP_BINARY_OP_EXCEPTION_MATCH, - // these are not supported by the runtime and must be synthesised by the emitter - MP_BINARY_OP_NOT_IN, - MP_BINARY_OP_IS_NOT, } mp_binary_op_t; typedef enum { diff --git a/tests/cmdline/cmd_showbc.py.exp b/tests/cmdline/cmd_showbc.py.exp index 1e015eb03..2dd927f74 100644 --- a/tests/cmdline/cmd_showbc.py.exp +++ b/tests/cmdline/cmd_showbc.py.exp @@ -43,9 +43,9 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+): bc=\\d\+ line=126 00 LOAD_CONST_NONE 01 LOAD_CONST_FALSE -02 BINARY_OP 5 __add__ +02 BINARY_OP 16 __add__ 03 LOAD_CONST_TRUE -04 BINARY_OP 5 __add__ +04 BINARY_OP 16 __add__ 05 STORE_FAST 0 06 LOAD_CONST_SMALL_INT 0 07 STORE_FAST 0 @@ -84,7 +84,7 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+): \\d\+ STORE_FAST 7 \\d\+ LOAD_FAST 0 \\d\+ LOAD_DEREF 14 -\\d\+ BINARY_OP 5 __add__ +\\d\+ BINARY_OP 16 __add__ \\d\+ STORE_FAST 8 \\d\+ LOAD_FAST 0 \\d\+ UNARY_OP 4 @@ -96,21 +96,21 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+): \\d\+ LOAD_DEREF 14 \\d\+ DUP_TOP \\d\+ ROT_THREE -\\d\+ BINARY_OP 27 __eq__ +\\d\+ BINARY_OP 2 __eq__ \\d\+ JUMP_IF_FALSE_OR_POP \\d\+ \\d\+ LOAD_FAST 1 -\\d\+ BINARY_OP 27 __eq__ +\\d\+ BINARY_OP 2 __eq__ \\d\+ JUMP \\d\+ \\d\+ ROT_TWO \\d\+ POP_TOP \\d\+ STORE_FAST 10 \\d\+ LOAD_FAST 0 \\d\+ LOAD_DEREF 14 -\\d\+ BINARY_OP 27 __eq__ +\\d\+ BINARY_OP 2 __eq__ \\d\+ JUMP_IF_FALSE_OR_POP \\d\+ \\d\+ LOAD_DEREF 14 \\d\+ LOAD_FAST 1 -\\d\+ BINARY_OP 27 __eq__ +\\d\+ BINARY_OP 2 __eq__ \\d\+ UNARY_OP 6 \\d\+ STORE_FAST 10 \\d\+ LOAD_DEREF 14 @@ -132,7 +132,7 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+): \\d\+ DUP_TOP_TWO \\d\+ LOAD_SUBSCR \\d\+ LOAD_FAST 12 -\\d\+ BINARY_OP 18 __iadd__ +\\d\+ BINARY_OP 29 __iadd__ \\d\+ ROT_THREE \\d\+ STORE_SUBSCR \\d\+ LOAD_DEREF 14 @@ -369,7 +369,7 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+): 42 STORE_FAST_N 19 44 LOAD_FAST 9 45 LOAD_FAST_N 19 -47 BINARY_OP 5 __add__ +47 BINARY_OP 16 __add__ 48 POP_TOP 49 LOAD_CONST_NONE 50 RETURN_VALUE @@ -521,7 +521,7 @@ arg names: * bc=\\d\+ line=113 00 LOAD_DEREF 0 02 LOAD_CONST_SMALL_INT 1 -03 BINARY_OP 5 __add__ +03 BINARY_OP 16 __add__ 04 STORE_FAST 1 05 LOAD_CONST_SMALL_INT 1 06 STORE_DEREF 0 @@ -540,7 +540,7 @@ arg names: * b bc=\\d\+ line=139 00 LOAD_FAST 1 01 LOAD_DEREF 0 -03 BINARY_OP 5 __add__ +03 BINARY_OP 16 __add__ 04 RETURN_VALUE mem: total=\\d\+, current=\\d\+, peak=\\d\+ stack: \\d\+ out of \\d\+ -- cgit v1.2.3 From 50b9329eba29a36b6948699aaea9473681d4f46b Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Thu, 7 Sep 2017 11:26:42 +0300 Subject: py/runtime0.h: Move MP_BINARY_OP_DIVMOD to the end of mp_binary_op_t. It starts a dichotomy of mp_binary_op_t values which can't appear in the bytecode. Another reason to move it is to VALUES of OP_* and OP_INPLACE_* nicely adjacent. This also will be needed for OP_REVERSE_*, to be soon introduced. --- py/runtime0.h | 6 +++++- tests/cmdline/cmd_showbc.py.exp | 2 +- 2 files changed, 6 insertions(+), 2 deletions(-) (limited to 'tests') diff --git a/py/runtime0.h b/py/runtime0.h index 074dac1e4..fd497a6d1 100644 --- a/py/runtime0.h +++ b/py/runtime0.h @@ -84,7 +84,6 @@ typedef enum { MP_BINARY_OP_MODULO, MP_BINARY_OP_POWER, - MP_BINARY_OP_DIVMOD, // not emitted by the compiler but supported by the runtime MP_BINARY_OP_INPLACE_OR, MP_BINARY_OP_INPLACE_XOR, @@ -99,6 +98,11 @@ typedef enum { MP_BINARY_OP_INPLACE_TRUE_DIVIDE, MP_BINARY_OP_INPLACE_MODULO, MP_BINARY_OP_INPLACE_POWER, + + // Operations below this line don't appear in bytecode, they + // just identify special methods. + + MP_BINARY_OP_DIVMOD, // not emitted by the compiler but supported by the runtime } mp_binary_op_t; typedef enum { diff --git a/tests/cmdline/cmd_showbc.py.exp b/tests/cmdline/cmd_showbc.py.exp index 2dd927f74..0919aac53 100644 --- a/tests/cmdline/cmd_showbc.py.exp +++ b/tests/cmdline/cmd_showbc.py.exp @@ -132,7 +132,7 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+): \\d\+ DUP_TOP_TWO \\d\+ LOAD_SUBSCR \\d\+ LOAD_FAST 12 -\\d\+ BINARY_OP 29 __iadd__ +\\d\+ BINARY_OP 28 __iadd__ \\d\+ ROT_THREE \\d\+ STORE_SUBSCR \\d\+ LOAD_DEREF 14 -- cgit v1.2.3 From b8ee7ab5b988f424e34e778fe3a679710d675efa Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Fri, 8 Sep 2017 00:10:10 +0300 Subject: py/runtime0.h: Put inplace arith ops in front of normal operations. This is to allow to place reverse ops immediately after normal ops, so they can be tested as one range (which is optimization for reverse ops introduction in the next patch). --- py/objint_mpz.c | 2 +- py/runtime0.h | 28 ++++++++++++++-------------- tests/cmdline/cmd_showbc.py.exp | 14 +++++++------- 3 files changed, 22 insertions(+), 22 deletions(-) (limited to 'tests') diff --git a/py/objint_mpz.c b/py/objint_mpz.c index c7a3074ba..0e318b492 100644 --- a/py/objint_mpz.c +++ b/py/objint_mpz.c @@ -221,7 +221,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i return mp_obj_new_float(flhs / frhs); #endif - } else if (op >= MP_BINARY_OP_OR) { + } else if (op >= MP_BINARY_OP_INPLACE_OR) { mp_obj_int_t *res = mp_obj_int_new_mpz(); switch (op) { diff --git a/py/runtime0.h b/py/runtime0.h index b34211d57..3cf5e530d 100644 --- a/py/runtime0.h +++ b/py/runtime0.h @@ -70,20 +70,6 @@ typedef enum { MP_BINARY_OP_IS_NOT, // Arithmetic operations - MP_BINARY_OP_OR, - MP_BINARY_OP_XOR, - MP_BINARY_OP_AND, - MP_BINARY_OP_LSHIFT, - MP_BINARY_OP_RSHIFT, - MP_BINARY_OP_ADD, - - MP_BINARY_OP_SUBTRACT, - MP_BINARY_OP_MULTIPLY, - MP_BINARY_OP_FLOOR_DIVIDE, - MP_BINARY_OP_TRUE_DIVIDE, - MP_BINARY_OP_MODULO, - MP_BINARY_OP_POWER, - MP_BINARY_OP_INPLACE_OR, MP_BINARY_OP_INPLACE_XOR, MP_BINARY_OP_INPLACE_AND, @@ -98,6 +84,20 @@ typedef enum { MP_BINARY_OP_INPLACE_MODULO, MP_BINARY_OP_INPLACE_POWER, + MP_BINARY_OP_OR, + MP_BINARY_OP_XOR, + MP_BINARY_OP_AND, + MP_BINARY_OP_LSHIFT, + MP_BINARY_OP_RSHIFT, + MP_BINARY_OP_ADD, + + MP_BINARY_OP_SUBTRACT, + MP_BINARY_OP_MULTIPLY, + MP_BINARY_OP_FLOOR_DIVIDE, + MP_BINARY_OP_TRUE_DIVIDE, + MP_BINARY_OP_MODULO, + MP_BINARY_OP_POWER, + // Operations below this line don't appear in bytecode, they // just identify special methods. diff --git a/tests/cmdline/cmd_showbc.py.exp b/tests/cmdline/cmd_showbc.py.exp index 0919aac53..0e66a013d 100644 --- a/tests/cmdline/cmd_showbc.py.exp +++ b/tests/cmdline/cmd_showbc.py.exp @@ -43,9 +43,9 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+): bc=\\d\+ line=126 00 LOAD_CONST_NONE 01 LOAD_CONST_FALSE -02 BINARY_OP 16 __add__ +02 BINARY_OP 28 __add__ 03 LOAD_CONST_TRUE -04 BINARY_OP 16 __add__ +04 BINARY_OP 28 __add__ 05 STORE_FAST 0 06 LOAD_CONST_SMALL_INT 0 07 STORE_FAST 0 @@ -84,7 +84,7 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+): \\d\+ STORE_FAST 7 \\d\+ LOAD_FAST 0 \\d\+ LOAD_DEREF 14 -\\d\+ BINARY_OP 16 __add__ +\\d\+ BINARY_OP 28 __add__ \\d\+ STORE_FAST 8 \\d\+ LOAD_FAST 0 \\d\+ UNARY_OP 4 @@ -132,7 +132,7 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+): \\d\+ DUP_TOP_TWO \\d\+ LOAD_SUBSCR \\d\+ LOAD_FAST 12 -\\d\+ BINARY_OP 28 __iadd__ +\\d\+ BINARY_OP 16 __iadd__ \\d\+ ROT_THREE \\d\+ STORE_SUBSCR \\d\+ LOAD_DEREF 14 @@ -369,7 +369,7 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+): 42 STORE_FAST_N 19 44 LOAD_FAST 9 45 LOAD_FAST_N 19 -47 BINARY_OP 16 __add__ +47 BINARY_OP 28 __add__ 48 POP_TOP 49 LOAD_CONST_NONE 50 RETURN_VALUE @@ -521,7 +521,7 @@ arg names: * bc=\\d\+ line=113 00 LOAD_DEREF 0 02 LOAD_CONST_SMALL_INT 1 -03 BINARY_OP 16 __add__ +03 BINARY_OP 28 __add__ 04 STORE_FAST 1 05 LOAD_CONST_SMALL_INT 1 06 STORE_DEREF 0 @@ -540,7 +540,7 @@ arg names: * b bc=\\d\+ line=139 00 LOAD_FAST 1 01 LOAD_DEREF 0 -03 BINARY_OP 16 __add__ +03 BINARY_OP 28 __add__ 04 RETURN_VALUE mem: total=\\d\+, current=\\d\+, peak=\\d\+ stack: \\d\+ out of \\d\+ -- cgit v1.2.3 From 0708dd495f19ac935641a914358470b1385c3baa Mon Sep 17 00:00:00 2001 From: Damien George Date: Fri, 8 Sep 2017 12:11:15 +1000 Subject: tests/run-bench-tests: Update locations of executables, now in ports/. --- tests/run-bench-tests | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'tests') diff --git a/tests/run-bench-tests b/tests/run-bench-tests index d48b4b7ec..f4a6776cb 100755 --- a/tests/run-bench-tests +++ b/tests/run-bench-tests @@ -13,10 +13,10 @@ from collections import defaultdict # to the correct executable. if os.name == 'nt': CPYTHON3 = os.getenv('MICROPY_CPYTHON3', 'python3.exe') - MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../windows/micropython.exe') + MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../ports/windows/micropython.exe') else: CPYTHON3 = os.getenv('MICROPY_CPYTHON3', 'python3') - MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../unix/micropython') + MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../ports/unix/micropython') def run_tests(pyb, test_dict): test_count = 0 -- cgit v1.2.3 From d6f9d64d97af245d042cbab8438dde25a29c504f Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Sun, 10 Sep 2017 17:05:31 +0300 Subject: tests/class_reverse_op: Test for reverse arith ops special methods. This test should be run only if support for reverse ops is enabled, so the corresponding feature_check is added to run-tests. --- ports/qemu-arm/mpconfigport.h | 1 + tests/basics/class_reverse_op.py | 18 ++++++++++++++++++ tests/feature_check/reverse_ops.py | 9 +++++++++ tests/feature_check/reverse_ops.py.exp | 0 tests/run-tests | 7 +++++++ 5 files changed, 35 insertions(+) create mode 100644 tests/basics/class_reverse_op.py create mode 100644 tests/feature_check/reverse_ops.py create mode 100644 tests/feature_check/reverse_ops.py.exp (limited to 'tests') diff --git a/ports/qemu-arm/mpconfigport.h b/ports/qemu-arm/mpconfigport.h index a12165a92..51706b927 100644 --- a/ports/qemu-arm/mpconfigport.h +++ b/ports/qemu-arm/mpconfigport.h @@ -18,6 +18,7 @@ #define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_FLOAT) #define MICROPY_CAN_OVERRIDE_BUILTINS (1) #define MICROPY_PY_ALL_SPECIAL_METHODS (1) +#define MICROPY_PY_REVERSE_SPECIAL_METHODS (1) #define MICROPY_PY_ARRAY_SLICE_ASSIGN (1) #define MICROPY_PY_BUILTINS_FROZENSET (1) #define MICROPY_PY_BUILTINS_MEMORYVIEW (1) diff --git a/tests/basics/class_reverse_op.py b/tests/basics/class_reverse_op.py new file mode 100644 index 000000000..d41c55c9d --- /dev/null +++ b/tests/basics/class_reverse_op.py @@ -0,0 +1,18 @@ +class A: + + def __init__(self, v): + self.v = v + + def __add__(self, o): + if isinstance(o, A): + return A(self.v + o.v) + return A(self.v + o) + + def __radd__(self, o): + return A(self.v + o) + + def __repr__(self): + return "A(%s)" % self.v + +print(A(3) + 1) +print(2 + A(5)) diff --git a/tests/feature_check/reverse_ops.py b/tests/feature_check/reverse_ops.py new file mode 100644 index 000000000..668748bc5 --- /dev/null +++ b/tests/feature_check/reverse_ops.py @@ -0,0 +1,9 @@ +class Foo: + + def __radd__(self, other): + pass + +try: + 5 + Foo() +except TypeError: + print("TypeError") diff --git a/tests/feature_check/reverse_ops.py.exp b/tests/feature_check/reverse_ops.py.exp new file mode 100644 index 000000000..e69de29bb diff --git a/tests/run-tests b/tests/run-tests index 14df1e986..c9f9efe77 100755 --- a/tests/run-tests +++ b/tests/run-tests @@ -207,6 +207,7 @@ def run_tests(pyb, tests, args, base_path="."): skip_set_type = False skip_async = False skip_const = False + skip_revops = False # Check if micropython.native is supported, and skip such tests if it's not native = run_feature_check(pyb, args, base_path, 'native_check.py') @@ -233,6 +234,11 @@ def run_tests(pyb, tests, args, base_path="."): if native == b'CRASH': skip_const = True + # Check if __rOP__ special methods are supported, and skip such tests if it's not + native = run_feature_check(pyb, args, base_path, 'reverse_ops.py') + if native == b'TypeError\n': + skip_revops = True + # Check if emacs repl is supported, and skip such tests if it's not t = run_feature_check(pyb, args, base_path, 'repl_emacs_check.py') if not 'True' in str(t, 'ascii'): @@ -360,6 +366,7 @@ def run_tests(pyb, tests, args, base_path="."): skip_it |= skip_set_type and is_set_type skip_it |= skip_async and is_async skip_it |= skip_const and is_const + skip_it |= skip_revops and test_name.startswith("class_reverse_op") if skip_it: print("skip ", test_file) -- cgit v1.2.3 From d1f909005a40469b9d933a7ad75bb3327030538e Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Sun, 10 Sep 2017 22:32:08 +0300 Subject: tests/run-tests: Skip class_inplace_op for minimal profile. Don't assume that MICROPY_PY_ALL_SPECIAL_METHODS is defined, as required for inplace special methods. Fixes Zephyr tests. --- tests/run-tests | 1 + 1 file changed, 1 insertion(+) (limited to 'tests') diff --git a/tests/run-tests b/tests/run-tests index c9f9efe77..2a43ff93d 100755 --- a/tests/run-tests +++ b/tests/run-tests @@ -308,6 +308,7 @@ def run_tests(pyb, tests, args, base_path="."): elif args.target == 'esp8266': skip_tests.add('misc/rge_sm.py') # too large elif args.target == 'minimal': + skip_tests.add('basics/class_inplace_op.py') # all special methods not supported skip_tests.add('misc/rge_sm.py') # too large skip_tests.add('micropython/opt_level.py') # don't assume line numbers are stored -- cgit v1.2.3 From f54b3527f20291bc7b158b675bebe39e381067d8 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Sun, 10 Sep 2017 22:38:18 +0300 Subject: tests/run-tests: Fix copy-paste mistake in var name. --- tests/run-tests | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) (limited to 'tests') diff --git a/tests/run-tests b/tests/run-tests index 2a43ff93d..866a9b7c3 100755 --- a/tests/run-tests +++ b/tests/run-tests @@ -210,33 +210,33 @@ def run_tests(pyb, tests, args, base_path="."): skip_revops = False # Check if micropython.native is supported, and skip such tests if it's not - native = run_feature_check(pyb, args, base_path, 'native_check.py') - if native == b'CRASH': + output = run_feature_check(pyb, args, base_path, 'native_check.py') + if output == b'CRASH': skip_native = True # Check if arbitrary-precision integers are supported, and skip such tests if it's not - native = run_feature_check(pyb, args, base_path, 'int_big.py') - if native != b'1000000000000000000000000000000000000000000000\n': + output = run_feature_check(pyb, args, base_path, 'int_big.py') + if output != b'1000000000000000000000000000000000000000000000\n': skip_int_big = True # Check if set type (and set literals) is supported, and skip such tests if it's not - native = run_feature_check(pyb, args, base_path, 'set_check.py') - if native == b'CRASH': + output = run_feature_check(pyb, args, base_path, 'set_check.py') + if output == b'CRASH': skip_set_type = True # Check if async/await keywords are supported, and skip such tests if it's not - native = run_feature_check(pyb, args, base_path, 'async_check.py') - if native == b'CRASH': + output = run_feature_check(pyb, args, base_path, 'async_check.py') + if output == b'CRASH': skip_async = True # Check if const keyword (MicroPython extension) is supported, and skip such tests if it's not - native = run_feature_check(pyb, args, base_path, 'const.py') - if native == b'CRASH': + output = run_feature_check(pyb, args, base_path, 'const.py') + if output == b'CRASH': skip_const = True # Check if __rOP__ special methods are supported, and skip such tests if it's not - native = run_feature_check(pyb, args, base_path, 'reverse_ops.py') - if native == b'TypeError\n': + output = run_feature_check(pyb, args, base_path, 'reverse_ops.py') + if output == b'TypeError\n': skip_revops = True # Check if emacs repl is supported, and skip such tests if it's not -- cgit v1.2.3 From 75163325ae3fc33ebb9919231289fadec620d124 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Sat, 16 Sep 2017 13:05:15 +0300 Subject: tests/cpydiff: Add cases for locals() discrepancies. MicroPython doesn't maintain local symbolic environment, so any feature depending on it won't work as expected. --- tests/cpydiff/core_locals.py | 11 +++++++++++ tests/cpydiff/core_locals_eval.py | 14 ++++++++++++++ 2 files changed, 25 insertions(+) create mode 100644 tests/cpydiff/core_locals.py create mode 100644 tests/cpydiff/core_locals_eval.py (limited to 'tests') diff --git a/tests/cpydiff/core_locals.py b/tests/cpydiff/core_locals.py new file mode 100644 index 000000000..0240e5a1a --- /dev/null +++ b/tests/cpydiff/core_locals.py @@ -0,0 +1,11 @@ +""" +categories: Core,Runtime +description: Local variables aren't included in locals() result +cause: MicroPython doesn't maintain symbolic local environment, it is optimized to an array of slots. Thus, local variables can't be accessed by a name. +workaround: Unknown +""" +def test(): + val = 2 + print(locals()) + +test() diff --git a/tests/cpydiff/core_locals_eval.py b/tests/cpydiff/core_locals_eval.py new file mode 100644 index 000000000..8416e3b06 --- /dev/null +++ b/tests/cpydiff/core_locals_eval.py @@ -0,0 +1,14 @@ +""" +categories: Core,Runtime +description: Code running in eval() function doesn't have access to local variables +cause: MicroPython doesn't maintain symbolic local environment, it is optimized to an array of slots. Thus, local variables can't be accessed by a name. Effectively, ``eval(expr)`` in MicroPython is equivalent to ``eval(expr, globals(), globals())``. +workaround: Unknown +""" +val = 1 + +def test(): + val = 2 + print(val) + eval("print(val)") + +test() -- cgit v1.2.3 From 9dce823cfd0a9991350184f08a1373f3887134f4 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Mon, 18 Sep 2017 00:06:43 +0300 Subject: py/modbuiltins: Implement abs() by dispatching to MP_UNARY_OP_ABS. This allows user classes to implement __abs__ special method, and saves code size (104 bytes for x86_64), even though during refactor, an issue was fixed and few optimizations were made: * abs() of minimum (negative) small int value is calculated properly. * objint_longlong and objint_mpz avoid allocating new object is the argument is already non-negative. --- py/modbuiltins.c | 21 +-------------------- py/objcomplex.c | 5 +++++ py/objfloat.c | 9 +++++++++ py/objint.c | 10 ---------- py/objint.h | 1 - py/objint_longlong.c | 34 ++++++++++------------------------ py/objint_mpz.c | 30 +++++++++--------------------- py/runtime.c | 9 +++++++++ py/runtime0.h | 1 + tests/unix/extra_coverage.py.exp | 2 +- 10 files changed, 45 insertions(+), 77 deletions(-) (limited to 'tests') diff --git a/py/modbuiltins.c b/py/modbuiltins.c index 1c76b8073..0486251b6 100644 --- a/py/modbuiltins.c +++ b/py/modbuiltins.c @@ -91,26 +91,7 @@ STATIC mp_obj_t mp_builtin___build_class__(size_t n_args, const mp_obj_t *args) MP_DEFINE_CONST_FUN_OBJ_VAR(mp_builtin___build_class___obj, 2, mp_builtin___build_class__); STATIC mp_obj_t mp_builtin_abs(mp_obj_t o_in) { - #if MICROPY_PY_BUILTINS_FLOAT - if (mp_obj_is_float(o_in)) { - mp_float_t value = mp_obj_float_get(o_in); - // TODO check for NaN etc - if (value < 0) { - return mp_obj_new_float(-value); - } else { - return o_in; - } - #if MICROPY_PY_BUILTINS_COMPLEX - } else if (MP_OBJ_IS_TYPE(o_in, &mp_type_complex)) { - mp_float_t real, imag; - mp_obj_complex_get(o_in, &real, &imag); - return mp_obj_new_float(MICROPY_FLOAT_C_FUN(sqrt)(real*real + imag*imag)); - #endif - } - #endif - - // this will raise a TypeError if the argument is not integral - return mp_obj_int_abs(o_in); + return mp_unary_op(MP_UNARY_OP_ABS, o_in); } MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_abs_obj, mp_builtin_abs); diff --git a/py/objcomplex.c b/py/objcomplex.c index 07b9d5d41..e7a3c244a 100644 --- a/py/objcomplex.c +++ b/py/objcomplex.c @@ -124,6 +124,11 @@ STATIC mp_obj_t complex_unary_op(mp_unary_op_t op, mp_obj_t o_in) { case MP_UNARY_OP_HASH: return MP_OBJ_NEW_SMALL_INT(mp_float_hash(o->real) ^ mp_float_hash(o->imag)); case MP_UNARY_OP_POSITIVE: return o_in; case MP_UNARY_OP_NEGATIVE: return mp_obj_new_complex(-o->real, -o->imag); + case MP_UNARY_OP_ABS: { + mp_float_t real, imag; + mp_obj_complex_get(o_in, &real, &imag); + return mp_obj_new_float(MICROPY_FLOAT_C_FUN(sqrt)(real*real + imag*imag)); + } default: return MP_OBJ_NULL; // op not supported } } diff --git a/py/objfloat.c b/py/objfloat.c index fadbbcb79..fefd78314 100644 --- a/py/objfloat.c +++ b/py/objfloat.c @@ -162,6 +162,15 @@ STATIC mp_obj_t float_unary_op(mp_unary_op_t op, mp_obj_t o_in) { case MP_UNARY_OP_HASH: return MP_OBJ_NEW_SMALL_INT(mp_float_hash(val)); case MP_UNARY_OP_POSITIVE: return o_in; case MP_UNARY_OP_NEGATIVE: return mp_obj_new_float(-val); + case MP_UNARY_OP_ABS: { + mp_float_t value = mp_obj_float_get(o_in); + // TODO check for NaN etc + if (value < 0) { + return mp_obj_new_float(-value); + } else { + return o_in; + } + } default: return MP_OBJ_NULL; // op not supported } } diff --git a/py/objint.c b/py/objint.c index 6a73b4382..000a0404c 100644 --- a/py/objint.c +++ b/py/objint.c @@ -314,16 +314,6 @@ int mp_obj_int_sign(mp_obj_t self_in) { } } -// This must handle int and bool types, and must raise a -// TypeError if the argument is not integral -mp_obj_t mp_obj_int_abs(mp_obj_t self_in) { - mp_int_t val = mp_obj_get_int(self_in); - if (val < 0) { - val = -val; - } - return MP_OBJ_NEW_SMALL_INT(val); -} - // This is called for operations on SMALL_INT that are not handled by mp_unary_op mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in) { return MP_OBJ_NULL; // op not supported diff --git a/py/objint.h b/py/objint.h index a4d4ff32d..4b95acde9 100644 --- a/py/objint.h +++ b/py/objint.h @@ -57,7 +57,6 @@ mp_int_t mp_obj_int_hash(mp_obj_t self_in); mp_obj_t mp_obj_int_from_bytes_impl(bool big_endian, size_t len, const byte *buf); void mp_obj_int_to_bytes_impl(mp_obj_t self_in, bool big_endian, size_t len, byte *buf); int mp_obj_int_sign(mp_obj_t self_in); -mp_obj_t mp_obj_int_abs(mp_obj_t self_in); mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in); mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in); mp_obj_t mp_obj_int_binary_op_extra_cases(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in); diff --git a/py/objint_longlong.c b/py/objint_longlong.c index ddfdae744..8d8ca1b2c 100644 --- a/py/objint_longlong.c +++ b/py/objint_longlong.c @@ -94,30 +94,6 @@ int mp_obj_int_sign(mp_obj_t self_in) { } } -// This must handle int and bool types, and must raise a -// TypeError if the argument is not integral -mp_obj_t mp_obj_int_abs(mp_obj_t self_in) { - if (MP_OBJ_IS_TYPE(self_in, &mp_type_int)) { - mp_obj_int_t *self = self_in; - self = mp_obj_new_int_from_ll(self->val); - if (self->val < 0) { - // TODO could overflow long long - self->val = -self->val; - } - return self; - } else { - mp_int_t val = mp_obj_get_int(self_in); - if (val == MP_SMALL_INT_MIN) { - return mp_obj_new_int_from_ll(-val); - } else { - if (val < 0) { - val = -val; - } - return MP_OBJ_NEW_SMALL_INT(val); - } - } -} - mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in) { mp_obj_int_t *o = o_in; switch (op) { @@ -130,6 +106,16 @@ mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in) { case MP_UNARY_OP_POSITIVE: return o_in; case MP_UNARY_OP_NEGATIVE: return mp_obj_new_int_from_ll(-o->val); case MP_UNARY_OP_INVERT: return mp_obj_new_int_from_ll(~o->val); + case MP_UNARY_OP_ABS: { + mp_obj_int_t *self = MP_OBJ_TO_PTR(o_in); + if (self->val >= 0) { + return o_in; + } + self = mp_obj_new_int_from_ll(self->val); + // TODO could overflow long long + self->val = -self->val; + return MP_OBJ_FROM_PTR(self); + } default: return MP_OBJ_NULL; // op not supported } } diff --git a/py/objint_mpz.c b/py/objint_mpz.c index 0e318b492..15aad1d4d 100644 --- a/py/objint_mpz.c +++ b/py/objint_mpz.c @@ -141,27 +141,6 @@ int mp_obj_int_sign(mp_obj_t self_in) { } } -// This must handle int and bool types, and must raise a -// TypeError if the argument is not integral -mp_obj_t mp_obj_int_abs(mp_obj_t self_in) { - if (MP_OBJ_IS_TYPE(self_in, &mp_type_int)) { - mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in); - mp_obj_int_t *self2 = mp_obj_int_new_mpz(); - mpz_abs_inpl(&self2->mpz, &self->mpz); - return MP_OBJ_FROM_PTR(self2); - } else { - mp_int_t val = mp_obj_get_int(self_in); - if (val == MP_SMALL_INT_MIN) { - return mp_obj_new_int_from_ll(-val); - } else { - if (val < 0) { - val = -val; - } - return MP_OBJ_NEW_SMALL_INT(val); - } - } -} - mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in) { mp_obj_int_t *o = MP_OBJ_TO_PTR(o_in); switch (op) { @@ -170,6 +149,15 @@ mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in) { case MP_UNARY_OP_POSITIVE: return o_in; case MP_UNARY_OP_NEGATIVE: { mp_obj_int_t *o2 = mp_obj_int_new_mpz(); mpz_neg_inpl(&o2->mpz, &o->mpz); return MP_OBJ_FROM_PTR(o2); } case MP_UNARY_OP_INVERT: { mp_obj_int_t *o2 = mp_obj_int_new_mpz(); mpz_not_inpl(&o2->mpz, &o->mpz); return MP_OBJ_FROM_PTR(o2); } + case MP_UNARY_OP_ABS: { + mp_obj_int_t *self = MP_OBJ_TO_PTR(o_in); + if (self->mpz.neg == 0) { + return o_in; + } + mp_obj_int_t *self2 = mp_obj_int_new_mpz(); + mpz_abs_inpl(&self2->mpz, &self->mpz); + return MP_OBJ_FROM_PTR(self2); + } default: return MP_OBJ_NULL; // op not supported } } diff --git a/py/runtime.c b/py/runtime.c index c533558da..f21eed204 100644 --- a/py/runtime.c +++ b/py/runtime.c @@ -231,6 +231,15 @@ mp_obj_t mp_unary_op(mp_unary_op_t op, mp_obj_t arg) { } else { return MP_OBJ_NEW_SMALL_INT(-val); } + case MP_UNARY_OP_ABS: + if (val >= 0) { + return arg; + } else if (val == MP_SMALL_INT_MIN) { + // check for overflow + return mp_obj_new_int(-val); + } else { + return MP_OBJ_NEW_SMALL_INT(-val); + } default: assert(op == MP_UNARY_OP_INVERT); return MP_OBJ_NEW_SMALL_INT(~val); diff --git a/py/runtime0.h b/py/runtime0.h index a3e9d46b9..54bf192d3 100644 --- a/py/runtime0.h +++ b/py/runtime0.h @@ -50,6 +50,7 @@ typedef enum { MP_UNARY_OP_NEGATIVE, MP_UNARY_OP_INVERT, MP_UNARY_OP_NOT, + MP_UNARY_OP_ABS, // __abs__ MP_UNARY_OP_SIZEOF, // for sys.getsizeof() } mp_unary_op_t; diff --git a/tests/unix/extra_coverage.py.exp b/tests/unix/extra_coverage.py.exp index ab638a632..4dc421dab 100644 --- a/tests/unix/extra_coverage.py.exp +++ b/tests/unix/extra_coverage.py.exp @@ -38,7 +38,7 @@ ementation 0 0 # runtime utils -TypeError: can't convert str to int +TypeError: unsupported type for : 'str' TypeError: unsupported types for : 'str', 'str' Warning: test # format float -- cgit v1.2.3 From fc9a6dd09e77c34ef04bab57e73bfcb08bc78bb4 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Tue, 19 Sep 2017 21:19:23 +0300 Subject: py/objstr: strip: Don't strip "\0" by default. An issue was due to incorrectly taking size of default strip characters set. --- py/objstr.c | 2 +- tests/basics/string_strip.py | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) (limited to 'tests') diff --git a/py/objstr.c b/py/objstr.c index f6214f80c..11bfb41fc 100644 --- a/py/objstr.c +++ b/py/objstr.c @@ -777,7 +777,7 @@ STATIC mp_obj_t str_uni_strip(int type, size_t n_args, const mp_obj_t *args) { if (n_args == 1) { chars_to_del = whitespace; - chars_to_del_len = sizeof(whitespace); + chars_to_del_len = sizeof(whitespace) - 1; } else { if (mp_obj_get_type(args[1]) != self_type) { bad_implicit_conversion(args[1]); diff --git a/tests/basics/string_strip.py b/tests/basics/string_strip.py index 5d99a78e5..971a4aae5 100644 --- a/tests/basics/string_strip.py +++ b/tests/basics/string_strip.py @@ -32,6 +32,13 @@ print("a ".strip()) print("a ".lstrip()) print("a ".rstrip()) +# \0 used to give a problem + +print("\0abc\0".strip()) +print("\0abc\0".lstrip()) +print("\0abc\0".rstrip()) +print("\0abc\0".strip("\0")) + # Test that stripping unstrippable string returns original object s = "abc" print(id(s.strip()) == id(s)) -- cgit v1.2.3 From 96fd80db1306ed67ee967b888c1c03c136bff4fb Mon Sep 17 00:00:00 2001 From: Damien George Date: Thu, 21 Sep 2017 15:24:57 +1000 Subject: py/objexcept: Prevent infinite recursion when allocating exceptions. The aim of this patch is to rewrite the functions that create exception instances (mp_obj_exception_make_new and mp_obj_new_exception_msg_varg) so that they do not call any functions that may raise an exception. Otherwise it's possible to create infinite recursion with an exception being raised while trying to create an exception object. The two main things that are done to accomplish this are: 1. Change mp_obj_new_exception_msg_varg to just format the string, then call mp_obj_exception_make_new to actually create the exception object. 2. In mp_obj_exception_make_new and mp_obj_new_exception_msg_varg try to allocate all memory first using functions that don't raise exceptions If any of the memory allocations fail (return NULL) then degrade gracefully by trying other options for memory allocation, eg using the emergency exception buffer. 3. Use a custom printer backend to conservatively format strings: if it can't allocate memory then it just truncates the string. As part of this rewrite, raising an exception without a message, like KeyError(123), will now use the emergency buffer to store the arg and traceback data if there is no heap memory available. Memory use with this patch is unchanged. Code size is increased by: bare-arm: +136 minimal x86: +124 unix x64: +72 unix nanbox: +96 stm32: +88 esp8266: +92 cc3200: +80 --- py/objexcept.c | 243 +++++++++++++++++++++++++-------------- tests/micropython/emg_exc.py | 16 ++- tests/micropython/emg_exc.py.exp | 5 +- tests/run-tests | 1 + 4 files changed, 176 insertions(+), 89 deletions(-) (limited to 'tests') diff --git a/py/objexcept.c b/py/objexcept.c index a9fe04094..0a03df9d0 100644 --- a/py/objexcept.c +++ b/py/objexcept.c @@ -38,6 +38,12 @@ #include "py/gc.h" #include "py/mperrno.h" +// Number of items per traceback entry (file, line, block) +#define TRACEBACK_ENTRY_LEN (3) + +// Number of traceback entries to reserve in the emergency exception buffer +#define EMG_TRACEBACK_ALLOC (2 * TRACEBACK_ENTRY_LEN) + // Instance of MemoryError exception - needed by mp_malloc_fail const mp_obj_exception_t mp_const_MemoryError_obj = {{&mp_type_MemoryError}, 0, 0, NULL, (mp_obj_tuple_t*)&mp_const_empty_tuple_obj}; @@ -127,18 +133,51 @@ STATIC void mp_obj_exception_print(const mp_print_t *print, mp_obj_t o_in, mp_pr mp_obj_t mp_obj_exception_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) { mp_arg_check_num(n_args, n_kw, 0, MP_OBJ_FUN_ARGS_MAX, false); - mp_obj_exception_t *o = m_new_obj_var_maybe(mp_obj_exception_t, mp_obj_t, 0); - if (o == NULL) { - // Couldn't allocate heap memory; use local data instead. - o = &MP_STATE_VM(mp_emergency_exception_obj); - // We can't store any args. - o->args = (mp_obj_tuple_t*)&mp_const_empty_tuple_obj; + + // Try to allocate memory for the exception, with fallback to emergency exception object + mp_obj_exception_t *o_exc = m_new_obj_maybe(mp_obj_exception_t); + if (o_exc == NULL) { + o_exc = &MP_STATE_VM(mp_emergency_exception_obj); + } + + // Populate the exception object + o_exc->base.type = type; + o_exc->traceback_data = NULL; + + mp_obj_tuple_t *o_tuple; + if (n_args == 0) { + // No args, can use the empty tuple straightaway + o_tuple = (mp_obj_tuple_t*)&mp_const_empty_tuple_obj; } else { - o->args = MP_OBJ_TO_PTR(mp_obj_new_tuple(n_args, args)); + // Try to allocate memory for the tuple containing the args + o_tuple = m_new_obj_var_maybe(mp_obj_tuple_t, mp_obj_t, n_args); + + #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF + // If we are called by mp_obj_new_exception_msg_varg then it will have + // reserved room (after the traceback data) for a tuple with 1 element. + // Otherwise we are free to use the whole buffer after the traceback data. + if (o_tuple == NULL && mp_emergency_exception_buf_size >= + EMG_TRACEBACK_ALLOC * sizeof(size_t) + sizeof(mp_obj_tuple_t) + n_args * sizeof(mp_obj_t)) { + o_tuple = (mp_obj_tuple_t*) + ((uint8_t*)MP_STATE_VM(mp_emergency_exception_buf) + EMG_TRACEBACK_ALLOC * sizeof(size_t)); + } + #endif + + if (o_tuple == NULL) { + // No memory for a tuple, fallback to an empty tuple + o_tuple = (mp_obj_tuple_t*)&mp_const_empty_tuple_obj; + } else { + // Have memory for a tuple so populate it + o_tuple->base.type = &mp_type_tuple; + o_tuple->len = n_args; + memcpy(o_tuple->items, args, n_args * sizeof(mp_obj_t)); + } } - o->base.type = type; - o->traceback_data = NULL; - return MP_OBJ_FROM_PTR(o); + + // Store the tuple of args in the exception object + o_exc->args = o_tuple; + + return MP_OBJ_FROM_PTR(o_exc); } // Get exception "value" - that is, first argument, or None @@ -306,87 +345,95 @@ mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const char *msg return mp_obj_new_exception_msg_varg(exc_type, msg); } -mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char *fmt, ...) { - // check that the given type is an exception type - assert(exc_type->make_new == mp_obj_exception_make_new); - - // make exception object - mp_obj_exception_t *o = m_new_obj_var_maybe(mp_obj_exception_t, mp_obj_t, 0); - if (o == NULL) { - // Couldn't allocate heap memory; use local data instead. - // Unfortunately, we won't be able to format the string... - o = &MP_STATE_VM(mp_emergency_exception_obj); - o->base.type = exc_type; - o->traceback_data = NULL; - o->args = (mp_obj_tuple_t*)&mp_const_empty_tuple_obj; - -#if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF - // If the user has provided a buffer, then we try to create a tuple - // of length 1, which has a string object and the string data. +// The following struct and function implement a simple printer that conservatively +// allocates memory and truncates the output data if no more memory can be obtained. +// It leaves room for a null byte at the end of the buffer. - if (mp_emergency_exception_buf_size > (sizeof(mp_obj_tuple_t) + sizeof(mp_obj_str_t) + sizeof(mp_obj_t))) { - mp_obj_tuple_t *tuple = (mp_obj_tuple_t *)MP_STATE_VM(mp_emergency_exception_buf); - mp_obj_str_t *str = (mp_obj_str_t *)&tuple->items[1]; - - tuple->base.type = &mp_type_tuple; - tuple->len = 1; - tuple->items[0] = MP_OBJ_FROM_PTR(str); - - byte *str_data = (byte *)&str[1]; - size_t max_len = (byte*)MP_STATE_VM(mp_emergency_exception_buf) + mp_emergency_exception_buf_size - - str_data; +struct _exc_printer_t { + bool allow_realloc; + size_t alloc; + size_t len; + byte *buf; +}; - vstr_t vstr; - vstr_init_fixed_buf(&vstr, max_len, (char *)str_data); +STATIC void exc_add_strn(void *data, const char *str, size_t len) { + struct _exc_printer_t *pr = data; + if (pr->len + len >= pr->alloc) { + // Not enough room for data plus a null byte so try to grow the buffer + if (pr->allow_realloc) { + size_t new_alloc = pr->alloc + len + 16; + byte *new_buf = m_renew_maybe(byte, pr->buf, pr->alloc, new_alloc, true); + if (new_buf == NULL) { + pr->allow_realloc = false; + len = pr->alloc - pr->len - 1; + } else { + pr->alloc = new_alloc; + pr->buf = new_buf; + } + } else { + len = pr->alloc - pr->len - 1; + } + } + memcpy(pr->buf + pr->len, str, len); + pr->len += len; +} - va_list ap; - va_start(ap, fmt); - vstr_vprintf(&vstr, fmt, ap); - va_end(ap); +mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char *fmt, ...) { + assert(fmt != NULL); - str->base.type = &mp_type_str; - str->hash = qstr_compute_hash(str_data, str->len); - str->len = vstr.len; - str->data = str_data; + // Check that the given type is an exception type + assert(exc_type->make_new == mp_obj_exception_make_new); - o->args = tuple; + // Try to allocate memory for the message + mp_obj_str_t *o_str = m_new_obj_maybe(mp_obj_str_t); + size_t o_str_alloc = strlen(fmt) + 1; + byte *o_str_buf = m_new_maybe(byte, o_str_alloc); + + bool used_emg_buf = false; + #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF + // If memory allocation failed and there is an emergency buffer then try to use + // that buffer to store the string object and its data (at least 16 bytes for + // the string data), reserving room at the start for the traceback and 1-tuple. + if ((o_str == NULL || o_str_buf == NULL) + && mp_emergency_exception_buf_size >= EMG_TRACEBACK_ALLOC * sizeof(size_t) + + sizeof(mp_obj_tuple_t) + sizeof(mp_obj_t) + sizeof(mp_obj_str_t) + 16) { + used_emg_buf = true; + o_str = (mp_obj_str_t*)((uint8_t*)MP_STATE_VM(mp_emergency_exception_buf) + + EMG_TRACEBACK_ALLOC * sizeof(size_t) + sizeof(mp_obj_tuple_t) + sizeof(mp_obj_t)); + o_str_buf = (byte*)&o_str[1]; + o_str_alloc = (uint8_t*)MP_STATE_VM(mp_emergency_exception_buf) + + mp_emergency_exception_buf_size - o_str_buf; + } + #endif - size_t offset = &str_data[str->len] - (byte*)MP_STATE_VM(mp_emergency_exception_buf); - offset += sizeof(void *) - 1; - offset &= ~(sizeof(void *) - 1); + if (o_str == NULL) { + // No memory for the string object so create the exception with no args + return mp_obj_exception_make_new(exc_type, 0, 0, NULL); + } - if ((mp_emergency_exception_buf_size - offset) > (sizeof(o->traceback_data[0]) * 3)) { - // We have room to store some traceback. - o->traceback_data = (size_t*)((byte *)MP_STATE_VM(mp_emergency_exception_buf) + offset); - o->traceback_alloc = ((byte*)MP_STATE_VM(mp_emergency_exception_buf) + mp_emergency_exception_buf_size - (byte *)o->traceback_data) / sizeof(o->traceback_data[0]); - o->traceback_len = 0; - } - } -#endif // MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF + if (o_str_buf == NULL) { + // No memory for the string buffer: assume that the fmt string is in ROM + // and use that data as the data of the string + o_str->len = o_str_alloc - 1; // will be equal to strlen(fmt) + o_str->data = (const byte*)fmt; } else { - o->base.type = exc_type; - o->traceback_data = NULL; - o->args = MP_OBJ_TO_PTR(mp_obj_new_tuple(1, NULL)); - - assert(fmt != NULL); - { - if (strchr(fmt, '%') == NULL) { - // no formatting substitutions, avoid allocating vstr. - o->args->items[0] = mp_obj_new_str(fmt, strlen(fmt), false); - } else { - // render exception message and store as .args[0] - va_list ap; - vstr_t vstr; - vstr_init(&vstr, 16); - va_start(ap, fmt); - vstr_vprintf(&vstr, fmt, ap); - va_end(ap); - o->args->items[0] = mp_obj_new_str_from_vstr(&mp_type_str, &vstr); - } - } + // We have some memory to format the string + struct _exc_printer_t exc_pr = {!used_emg_buf, o_str_alloc, 0, o_str_buf}; + mp_print_t print = {&exc_pr, exc_add_strn}; + va_list ap; + va_start(ap, fmt); + mp_vprintf(&print, fmt, ap); + va_end(ap); + exc_pr.buf[exc_pr.len] = '\0'; + o_str->len = exc_pr.len; + o_str->data = exc_pr.buf; } - return MP_OBJ_FROM_PTR(o); + // Create the string object and call mp_obj_exception_make_new to create the exception + o_str->base.type = &mp_type_str; + o_str->hash = qstr_compute_hash(o_str->data, o_str->len); + mp_obj_t arg = MP_OBJ_FROM_PTR(o_str); + return mp_obj_exception_make_new(exc_type, 1, 0, &arg); } // return true if the given object is an exception type @@ -443,24 +490,46 @@ void mp_obj_exception_add_traceback(mp_obj_t self_in, qstr file, size_t line, qs // if memory allocation fails (eg because gc is locked), just return if (self->traceback_data == NULL) { - self->traceback_data = m_new_maybe(size_t, 3); + self->traceback_data = m_new_maybe(size_t, TRACEBACK_ENTRY_LEN); if (self->traceback_data == NULL) { + #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF + if (mp_emergency_exception_buf_size >= EMG_TRACEBACK_ALLOC * sizeof(size_t)) { + // There is room in the emergency buffer for traceback data + size_t *tb = (size_t*)MP_STATE_VM(mp_emergency_exception_buf); + self->traceback_data = tb; + self->traceback_alloc = EMG_TRACEBACK_ALLOC; + } else { + // Can't allocate and no room in emergency buffer + return; + } + #else + // Can't allocate return; + #endif + } else { + // Allocated the traceback data on the heap + self->traceback_alloc = TRACEBACK_ENTRY_LEN; } - self->traceback_alloc = 3; self->traceback_len = 0; - } else if (self->traceback_len + 3 > self->traceback_alloc) { + } else if (self->traceback_len + TRACEBACK_ENTRY_LEN > self->traceback_alloc) { + #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF + if (self->traceback_data == (size_t*)MP_STATE_VM(mp_emergency_exception_buf)) { + // Can't resize the emergency buffer + return; + } + #endif // be conservative with growing traceback data - size_t *tb_data = m_renew_maybe(size_t, self->traceback_data, self->traceback_alloc, self->traceback_alloc + 3, true); + size_t *tb_data = m_renew_maybe(size_t, self->traceback_data, self->traceback_alloc, + self->traceback_alloc + TRACEBACK_ENTRY_LEN, true); if (tb_data == NULL) { return; } self->traceback_data = tb_data; - self->traceback_alloc += 3; + self->traceback_alloc += TRACEBACK_ENTRY_LEN; } size_t *tb_data = &self->traceback_data[self->traceback_len]; - self->traceback_len += 3; + self->traceback_len += TRACEBACK_ENTRY_LEN; tb_data[0] = file; tb_data[1] = line; tb_data[2] = block; diff --git a/tests/micropython/emg_exc.py b/tests/micropython/emg_exc.py index d228e6faa..4a9fa18bc 100644 --- a/tests/micropython/emg_exc.py +++ b/tests/micropython/emg_exc.py @@ -2,6 +2,11 @@ import micropython import sys +try: + import uio +except ImportError: + print("SKIP") + raise SystemExit # some ports need to allocate heap for the emg exc try: @@ -14,7 +19,16 @@ def f(): try: raise ValueError(1) except ValueError as er: - sys.print_exception(er) + exc = er micropython.heap_unlock() + # print the exception + buf = uio.StringIO() + sys.print_exception(exc, buf) + for l in buf.getvalue().split("\n"): + if l.startswith(" File "): + print(l.split('"')[2]) + else: + print(l) + f() diff --git a/tests/micropython/emg_exc.py.exp b/tests/micropython/emg_exc.py.exp index 82b10b5f5..fd2cfb272 100644 --- a/tests/micropython/emg_exc.py.exp +++ b/tests/micropython/emg_exc.py.exp @@ -1 +1,4 @@ -ValueError: +Traceback (most recent call last): +, line 20, in f +ValueError: 1 + diff --git a/tests/run-tests b/tests/run-tests index 866a9b7c3..568d99f8e 100755 --- a/tests/run-tests +++ b/tests/run-tests @@ -345,6 +345,7 @@ def run_tests(pyb, tests, args, base_path="."): skip_tests.add('misc/rge_sm.py') # requires yield skip_tests.add('misc/print_exception.py') # because native doesn't have proper traceback info skip_tests.add('misc/sys_exc_info.py') # sys.exc_info() is not supported for native + skip_tests.add('micropython/emg_exc.py') # because native doesn't have proper traceback info skip_tests.add('micropython/heapalloc_traceback.py') # because native doesn't have proper traceback info skip_tests.add('micropython/heapalloc_iter.py') # requires generators skip_tests.add('micropython/schedule.py') # native code doesn't check pending events -- cgit v1.2.3 From ede8a0235b47333aaaa8d03a3b9e20b014be3808 Mon Sep 17 00:00:00 2001 From: Damien George Date: Fri, 1 Sep 2017 08:05:24 +1000 Subject: py/vstr: Raise a RuntimeError if fixed vstr buffer overflows. Current users of fixed vstr buffers (building file paths) assume that there is no overflow and do not check for overflow after building the vstr. This has the potential to lead to NULL pointer dereferences (when vstr_null_terminated_str returns NULL because it can't allocate RAM for the terminating byte) and stat'ing and loading invalid path names (due to the path being truncated). The safest and simplest thing to do in these cases is just raise an exception if a write goes beyond the end of a fixed vstr buffer, which is what this patch does. It also simplifies the vstr code. --- ports/unix/coverage.c | 17 ++++++++++-- py/vstr.c | 59 ++++++++++------------------------------ tests/unix/extra_coverage.py.exp | 3 +- 3 files changed, 31 insertions(+), 48 deletions(-) (limited to 'tests') diff --git a/ports/unix/coverage.c b/ports/unix/coverage.c index 4a9ab194b..651db0a94 100644 --- a/ports/unix/coverage.c +++ b/ports/unix/coverage.c @@ -181,8 +181,21 @@ STATIC mp_obj_t extra_coverage(void) { mp_printf(&mp_plat_print, "%.*s\n", (int)vstr->len, vstr->buf); VSTR_FIXED(fix, 4); - vstr_add_str(&fix, "large"); - mp_printf(&mp_plat_print, "%.*s\n", (int)fix.len, fix.buf); + nlr_buf_t nlr; + if (nlr_push(&nlr) == 0) { + vstr_add_str(&fix, "large"); + nlr_pop(); + } else { + mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val)); + } + + fix.len = fix.alloc; + if (nlr_push(&nlr) == 0) { + vstr_null_terminated_str(&fix); + nlr_pop(); + } else { + mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val)); + } } // repl autocomplete diff --git a/py/vstr.c b/py/vstr.c index 8a00f6c6f..869b27805 100644 --- a/py/vstr.c +++ b/py/vstr.c @@ -30,7 +30,7 @@ #include #include "py/mpconfig.h" -#include "py/misc.h" +#include "py/runtime.h" #include "py/mpprint.h" // returned value is always at least 1 greater than argument @@ -92,7 +92,9 @@ void vstr_free(vstr_t *vstr) { // Extend vstr strictly by requested size, return pointer to newly added chunk. char *vstr_extend(vstr_t *vstr, size_t size) { if (vstr->fixed_buf) { - return NULL; + // We can't reallocate, and the caller is expecting the space to + // be there, so the only safe option is to raise an exception. + mp_raise_msg(&mp_type_RuntimeError, NULL); } char *new_buf = m_renew(char, vstr->buf, vstr->alloc, vstr->alloc + size); char *p = new_buf + vstr->alloc; @@ -101,17 +103,18 @@ char *vstr_extend(vstr_t *vstr, size_t size) { return p; } -STATIC bool vstr_ensure_extra(vstr_t *vstr, size_t size) { +STATIC void vstr_ensure_extra(vstr_t *vstr, size_t size) { if (vstr->len + size > vstr->alloc) { if (vstr->fixed_buf) { - return false; + // We can't reallocate, and the caller is expecting the space to + // be there, so the only safe option is to raise an exception. + mp_raise_msg(&mp_type_RuntimeError, NULL); } size_t new_alloc = ROUND_ALLOC((vstr->len + size) + 16); char *new_buf = m_renew(char, vstr->buf, vstr->alloc, new_alloc); vstr->alloc = new_alloc; vstr->buf = new_buf; } - return true; } void vstr_hint_size(vstr_t *vstr, size_t size) { @@ -119,9 +122,7 @@ void vstr_hint_size(vstr_t *vstr, size_t size) { } char *vstr_add_len(vstr_t *vstr, size_t len) { - if (!vstr_ensure_extra(vstr, len)) { - return NULL; - } + vstr_ensure_extra(vstr, len); char *buf = vstr->buf + vstr->len; vstr->len += len; return buf; @@ -131,9 +132,7 @@ char *vstr_add_len(vstr_t *vstr, size_t len) { char *vstr_null_terminated_str(vstr_t *vstr) { // If there's no more room, add single byte if (vstr->alloc == vstr->len) { - if (vstr_extend(vstr, 1) == NULL) { - return NULL; - } + vstr_extend(vstr, 1); } vstr->buf[vstr->len] = '\0'; return vstr->buf; @@ -141,9 +140,6 @@ char *vstr_null_terminated_str(vstr_t *vstr) { void vstr_add_byte(vstr_t *vstr, byte b) { byte *buf = (byte*)vstr_add_len(vstr, 1); - if (buf == NULL) { - return; - } buf[0] = b; } @@ -153,31 +149,19 @@ void vstr_add_char(vstr_t *vstr, unichar c) { // Is it worth just calling vstr_add_len(vstr, 4)? if (c < 0x80) { byte *buf = (byte*)vstr_add_len(vstr, 1); - if (buf == NULL) { - return; - } *buf = (byte)c; } else if (c < 0x800) { byte *buf = (byte*)vstr_add_len(vstr, 2); - if (buf == NULL) { - return; - } buf[0] = (c >> 6) | 0xC0; buf[1] = (c & 0x3F) | 0x80; } else if (c < 0x10000) { byte *buf = (byte*)vstr_add_len(vstr, 3); - if (buf == NULL) { - return; - } buf[0] = (c >> 12) | 0xE0; buf[1] = ((c >> 6) & 0x3F) | 0x80; buf[2] = (c & 0x3F) | 0x80; } else { assert(c < 0x110000); byte *buf = (byte*)vstr_add_len(vstr, 4); - if (buf == NULL) { - return; - } buf[0] = (c >> 18) | 0xF0; buf[1] = ((c >> 12) & 0x3F) | 0x80; buf[2] = ((c >> 6) & 0x3F) | 0x80; @@ -193,16 +177,7 @@ void vstr_add_str(vstr_t *vstr, const char *str) { } void vstr_add_strn(vstr_t *vstr, const char *str, size_t len) { - if (!vstr_ensure_extra(vstr, len)) { - // if buf is fixed, we got here because there isn't enough room left - // so just try to copy as much as we can, with room for a possible null byte - if (vstr->fixed_buf && vstr->len < vstr->alloc) { - len = vstr->alloc - vstr->len; - goto copy; - } - return; - } -copy: + vstr_ensure_extra(vstr, len); memmove(vstr->buf + vstr->len, str, len); vstr->len += len; } @@ -214,9 +189,7 @@ STATIC char *vstr_ins_blank_bytes(vstr_t *vstr, size_t byte_pos, size_t byte_len } if (byte_len > 0) { // ensure room for the new bytes - if (!vstr_ensure_extra(vstr, byte_len)) { - return NULL; - } + vstr_ensure_extra(vstr, byte_len); // copy up the string to make room for the new bytes memmove(vstr->buf + byte_pos + byte_len, vstr->buf + byte_pos, l - byte_pos); // increase the length @@ -227,17 +200,13 @@ STATIC char *vstr_ins_blank_bytes(vstr_t *vstr, size_t byte_pos, size_t byte_len void vstr_ins_byte(vstr_t *vstr, size_t byte_pos, byte b) { char *s = vstr_ins_blank_bytes(vstr, byte_pos, 1); - if (s != NULL) { - *s = b; - } + *s = b; } void vstr_ins_char(vstr_t *vstr, size_t char_pos, unichar chr) { // TODO UNICODE char *s = vstr_ins_blank_bytes(vstr, char_pos, 1); - if (s != NULL) { - *s = chr; - } + *s = chr; } void vstr_cut_head_bytes(vstr_t *vstr, size_t bytes_to_cut) { diff --git a/tests/unix/extra_coverage.py.exp b/tests/unix/extra_coverage.py.exp index 4dc421dab..4c4f66663 100644 --- a/tests/unix/extra_coverage.py.exp +++ b/tests/unix/extra_coverage.py.exp @@ -18,7 +18,8 @@ sts test tes -larg +RuntimeError: +RuntimeError: # repl ame__ -- cgit v1.2.3 From 9d836fedbdb1d28bdfc4ba475bbdfc1adb3f007a Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Mon, 25 Sep 2017 16:35:19 -0700 Subject: py: Clarify which mp_unary_op_t's may appear in the bytecode. Not all can, so we don't need to reserve bytecodes for them, and can use free slots for something else later. --- py/bc0.h | 2 +- py/runtime0.h | 14 +++++++++----- py/showbc.c | 2 +- py/vmentrytable.h | 2 +- tests/cmdline/cmd_showbc.py.exp | 6 +++--- 5 files changed, 15 insertions(+), 11 deletions(-) (limited to 'tests') diff --git a/py/bc0.h b/py/bc0.h index f671c5b5a..38e23c0fd 100644 --- a/py/bc0.h +++ b/py/bc0.h @@ -113,7 +113,7 @@ #define MP_BC_LOAD_CONST_SMALL_INT_MULTI (0x70) // + N(64) #define MP_BC_LOAD_FAST_MULTI (0xb0) // + N(16) #define MP_BC_STORE_FAST_MULTI (0xc0) // + N(16) -#define MP_BC_UNARY_OP_MULTI (0xd0) // + op(7) +#define MP_BC_UNARY_OP_MULTI (0xd0) // + op( Date: Sun, 24 Sep 2017 20:15:48 -0500 Subject: py: Add config option to print warnings/errors to stderr. This adds a new configuration option to print runtime warnings and errors to stderr. On Unix, CPython prints warnings and unhandled exceptions to stderr, so the unix port here is configured to use this option. The unix port already printed unhandled exceptions on the main thread to stderr. This patch fixes unhandled exceptions on other threads and warnings (issue #2838) not printing on stderr. Additionally, a couple tests needed to be fixed to handle this new behavior. This is done by also capturing stderr when running tests. --- ports/unix/mpconfigport.h | 3 +++ py/modthread.c | 8 ++++---- py/mpconfig.h | 5 +++++ py/warning.c | 6 +++--- tests/run-tests | 4 ++-- 5 files changed, 17 insertions(+), 9 deletions(-) (limited to 'tests') diff --git a/ports/unix/mpconfigport.h b/ports/unix/mpconfigport.h index b557f3d44..50b979279 100644 --- a/ports/unix/mpconfigport.h +++ b/ports/unix/mpconfigport.h @@ -145,8 +145,11 @@ // names in exception messages (may require more RAM). #define MICROPY_ERROR_REPORTING (MICROPY_ERROR_REPORTING_DETAILED) #define MICROPY_WARNINGS (1) +#define MICROPY_ERROR_PRINTER (&mp_stderr_print) #define MICROPY_PY_STR_BYTES_CMP_WARN (1) +extern const struct _mp_print_t mp_stderr_print; + // Define to 1 to use undertested inefficient GC helper implementation // (if more efficient arch-specific one is not available). #ifndef MICROPY_GCREGS_SETJMP diff --git a/py/modthread.c b/py/modthread.c index bf74128e8..cb071d0f8 100644 --- a/py/modthread.c +++ b/py/modthread.c @@ -192,10 +192,10 @@ STATIC void *thread_entry(void *args_in) { // swallow exception silently } else { // print exception out - mp_printf(&mp_plat_print, "Unhandled exception in thread started by "); - mp_obj_print_helper(&mp_plat_print, args->fun, PRINT_REPR); - mp_printf(&mp_plat_print, "\n"); - mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(exc)); + mp_printf(MICROPY_ERROR_PRINTER, "Unhandled exception in thread started by "); + mp_obj_print_helper(MICROPY_ERROR_PRINTER, args->fun, PRINT_REPR); + mp_printf(MICROPY_ERROR_PRINTER, "\n"); + mp_obj_print_exception(MICROPY_ERROR_PRINTER, MP_OBJ_FROM_PTR(exc)); } } diff --git a/py/mpconfig.h b/py/mpconfig.h index b93f851d6..44de3beeb 100644 --- a/py/mpconfig.h +++ b/py/mpconfig.h @@ -533,6 +533,11 @@ typedef long long mp_longint_impl_t; #define MICROPY_WARNINGS (0) #endif +// This macro is used when printing runtime warnings and errors +#ifndef MICROPY_ERROR_PRINTER +#define MICROPY_ERROR_PRINTER (&mp_plat_print) +#endif + // Float and complex implementation #define MICROPY_FLOAT_IMPL_NONE (0) #define MICROPY_FLOAT_IMPL_FLOAT (1) diff --git a/py/warning.c b/py/warning.c index 46b31ecca..12d0f9c99 100644 --- a/py/warning.c +++ b/py/warning.c @@ -35,9 +35,9 @@ void mp_warning(const char *msg, ...) { va_list args; va_start(args, msg); - mp_print_str(&mp_plat_print, "Warning: "); - mp_vprintf(&mp_plat_print, msg, args); - mp_print_str(&mp_plat_print, "\n"); + mp_print_str(MICROPY_ERROR_PRINTER, "Warning: "); + mp_vprintf(MICROPY_ERROR_PRINTER, msg, args); + mp_print_str(MICROPY_ERROR_PRINTER, "\n"); va_end(args); } diff --git a/tests/run-tests b/tests/run-tests index 568d99f8e..23fc3d910 100755 --- a/tests/run-tests +++ b/tests/run-tests @@ -103,7 +103,7 @@ def run_micropython(pyb, args, test_file, is_special=False): os.close(master) os.close(slave) else: - output_mupy = subprocess.check_output(args + [test_file]) + output_mupy = subprocess.check_output(args + [test_file], stderr=subprocess.STDOUT) except subprocess.CalledProcessError: return b'CRASH' @@ -124,7 +124,7 @@ def run_micropython(pyb, args, test_file, is_special=False): # run the actual test try: - output_mupy = subprocess.check_output(cmdlist) + output_mupy = subprocess.check_output(cmdlist, stderr=subprocess.STDOUT) except subprocess.CalledProcessError: output_mupy = b'CRASH' -- cgit v1.2.3 From bdc6e86e079dd8a82e9ead1d4041c2e17c882437 Mon Sep 17 00:00:00 2001 From: Damien George Date: Tue, 26 Sep 2017 12:57:51 +1000 Subject: py/objfloat: Support raising a negative number to a fractional power. This returns a complex number, following CPython behaviour. For ports that don't have complex numbers enabled this will raise a ValueError which gives a fail-safe for scripts that were written assuming complex numbers exist. --- py/objfloat.c | 7 +++++++ tests/float/complex1.py | 4 ++++ 2 files changed, 11 insertions(+) (limited to 'tests') diff --git a/py/objfloat.c b/py/objfloat.c index 55a9379ff..0831be3fd 100644 --- a/py/objfloat.c +++ b/py/objfloat.c @@ -298,6 +298,13 @@ mp_obj_t mp_obj_float_binary_op(mp_binary_op_t op, mp_float_t lhs_val, mp_obj_t if (lhs_val == 0 && rhs_val < 0) { goto zero_division_error; } + if (lhs_val < 0 && rhs_val != MICROPY_FLOAT_C_FUN(floor)(rhs_val)) { + #if MICROPY_PY_BUILTINS_COMPLEX + return mp_obj_complex_binary_op(MP_BINARY_OP_POWER, lhs_val, 0, rhs_in); + #else + mp_raise_ValueError("complex values not supported"); + #endif + } lhs_val = MICROPY_FLOAT_C_FUN(pow)(lhs_val, rhs_val); break; case MP_BINARY_OP_DIVMOD: { diff --git a/tests/float/complex1.py b/tests/float/complex1.py index 7f0b317b3..854410545 100644 --- a/tests/float/complex1.py +++ b/tests/float/complex1.py @@ -53,6 +53,10 @@ print(type(hash(1j))) # float on lhs should delegate to complex print(1.2 + 3j) +# negative base and fractional power should create a complex +ans = (-1) ** 2.3; print("%.5g %.5g" % (ans.real, ans.imag)) +ans = (-1.2) ** -3.4; print("%.5g %.5g" % (ans.real, ans.imag)) + # check printing of inf/nan print(float('nan') * 1j) print(float('inf') * (1 + 1j)) -- cgit v1.2.3 From 8e0b9f495b1967bf7503bfe4e66687955eee1922 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Tue, 3 Oct 2017 00:24:32 +0300 Subject: tests/extmod: Add test for ure regexes leading to infinite recursion. These now should be caught properly and lead to RuntimeError instead of crash. --- tests/extmod/ure_stack_overflow.py | 13 +++++++++++++ tests/extmod/ure_stack_overflow.py.exp | 1 + 2 files changed, 14 insertions(+) create mode 100644 tests/extmod/ure_stack_overflow.py create mode 100644 tests/extmod/ure_stack_overflow.py.exp (limited to 'tests') diff --git a/tests/extmod/ure_stack_overflow.py b/tests/extmod/ure_stack_overflow.py new file mode 100644 index 000000000..d3ce0c5a7 --- /dev/null +++ b/tests/extmod/ure_stack_overflow.py @@ -0,0 +1,13 @@ +try: + import ure as re +except ImportError: + try: + import re + except ImportError: + print("SKIP") + raise SystemExit + +try: + re.match("(a*)*", "aaa") +except RuntimeError: + print("RuntimeError") diff --git a/tests/extmod/ure_stack_overflow.py.exp b/tests/extmod/ure_stack_overflow.py.exp new file mode 100644 index 000000000..8a2b9bfdd --- /dev/null +++ b/tests/extmod/ure_stack_overflow.py.exp @@ -0,0 +1 @@ +RuntimeError -- cgit v1.2.3 From 2ac1364688cd3ee313661e82a336663551986fc8 Mon Sep 17 00:00:00 2001 From: Damien George Date: Tue, 3 Oct 2017 17:56:27 +1100 Subject: py/objset: Check that RHS of a binary op is a set/frozenset. CPython docs explicitly state that the RHS of a set/frozenset binary op must be a set to prevent user errors. It also preserves commutativity of the ops, eg: "abc" & set() is a TypeError, and so should be set() & "abc". This change actually decreases unix (x64) code by 160 bytes; it increases stm32 by 4 bytes and esp8266 by 28 bytes (but previous patch already introduced a much large saving). --- py/objset.c | 4 ++++ tests/basics/set_binop.py | 12 ++++++++++++ tests/misc/non_compliant.py | 12 ------------ tests/misc/non_compliant.py.exp | 2 -- 4 files changed, 16 insertions(+), 14 deletions(-) (limited to 'tests') diff --git a/py/objset.c b/py/objset.c index 6dede887c..80ed26334 100644 --- a/py/objset.c +++ b/py/objset.c @@ -463,6 +463,10 @@ STATIC mp_obj_t set_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) { #else bool update = true; #endif + if (op != MP_BINARY_OP_IN && !is_set_or_frozenset(rhs)) { + // For all ops except containment the RHS must be a set/frozenset + return MP_OBJ_NULL; + } switch (op) { case MP_BINARY_OP_OR: return set_union(lhs, rhs); diff --git a/tests/basics/set_binop.py b/tests/basics/set_binop.py index 7848920b6..bc76533b1 100644 --- a/tests/basics/set_binop.py +++ b/tests/basics/set_binop.py @@ -47,6 +47,18 @@ s1 = s2 = set('abc') s1 -= set('ad') print(s1 is s2, len(s1)) +# RHS must be a set +try: + print(set('12') >= '1') +except TypeError: + print('TypeError') + +# RHS must be a set +try: + print(set('12') <= '123') +except TypeError: + print('TypeError') + # unsupported operator try: set('abc') * 2 diff --git a/tests/misc/non_compliant.py b/tests/misc/non_compliant.py index b4c90e9fc..152633c3b 100644 --- a/tests/misc/non_compliant.py +++ b/tests/misc/non_compliant.py @@ -39,18 +39,6 @@ try: except NotImplementedError: print('NotImplementedError') -# should raise type error -try: - print(set('12') >= '1') -except TypeError: - print('TypeError') - -# should raise type error -try: - print(set('12') <= '123') -except TypeError: - print('TypeError') - # uPy raises TypeError, shold be ValueError try: '%c' % b'\x01\x02' diff --git a/tests/misc/non_compliant.py.exp b/tests/misc/non_compliant.py.exp index ba5590acc..9c157fd5b 100644 --- a/tests/misc/non_compliant.py.exp +++ b/tests/misc/non_compliant.py.exp @@ -3,8 +3,6 @@ AttributeError TypeError NotImplementedError NotImplementedError -True -True TypeError, ValueError NotImplementedError NotImplementedError -- cgit v1.2.3 From 1394258f378e50966daa1d83053067eeee8ef07d Mon Sep 17 00:00:00 2001 From: Damien George Date: Tue, 3 Oct 2017 18:03:06 +1100 Subject: py/objset: Include the failed key in a KeyError raised from set.remove. --- py/objset.c | 2 +- tests/basics/set_remove.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'tests') diff --git a/py/objset.c b/py/objset.c index 80ed26334..aefc26aac 100644 --- a/py/objset.c +++ b/py/objset.c @@ -380,7 +380,7 @@ STATIC mp_obj_t set_remove(mp_obj_t self_in, mp_obj_t item) { check_set(self_in); mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in); if (mp_set_lookup(&self->set, item, MP_MAP_LOOKUP_REMOVE_IF_FOUND) == MP_OBJ_NULL) { - nlr_raise(mp_obj_new_exception(&mp_type_KeyError)); + nlr_raise(mp_obj_new_exception_arg1(&mp_type_KeyError, item)); } return mp_const_none; } diff --git a/tests/basics/set_remove.py b/tests/basics/set_remove.py index 5627516c4..072723911 100644 --- a/tests/basics/set_remove.py +++ b/tests/basics/set_remove.py @@ -4,8 +4,8 @@ print(s.remove(1)) print(list(s)) try: print(s.remove(1), "!!!") -except KeyError: - pass +except KeyError as er: + print('KeyError', er.args[0]) else: print("failed to raise KeyError") -- cgit v1.2.3 From dfa563c71fead671931e91b786cd649eed517f92 Mon Sep 17 00:00:00 2001 From: Damien George Date: Wed, 4 Oct 2017 17:59:22 +1100 Subject: py/objstr: Make empty bytes object have a null-terminating byte. Because a lot of string processing functions assume there is a null terminating byte, so they can work in an efficient way. Fixes issue #3334. --- py/objstr.c | 4 ++-- tests/basics/bytes.py | 3 +++ 2 files changed, 5 insertions(+), 2 deletions(-) (limited to 'tests') diff --git a/py/objstr.c b/py/objstr.c index d17b0a68c..51da7a418 100644 --- a/py/objstr.c +++ b/py/objstr.c @@ -1973,8 +1973,8 @@ const mp_obj_type_t mp_type_bytes = { .locals_dict = (mp_obj_dict_t*)&str8_locals_dict, }; -// the zero-length bytes -const mp_obj_str_t mp_const_empty_bytes_obj = {{&mp_type_bytes}, 0, 0, NULL}; +// The zero-length bytes object, with data that includes a null-terminating byte +const mp_obj_str_t mp_const_empty_bytes_obj = {{&mp_type_bytes}, 0, 0, (const byte*)""}; // Create a str/bytes object using the given data. New memory is allocated and // the data is copied across. diff --git a/tests/basics/bytes.py b/tests/basics/bytes.py index d3da15c8e..1d97e6b16 100644 --- a/tests/basics/bytes.py +++ b/tests/basics/bytes.py @@ -8,6 +8,9 @@ print(b'\u1234') print(bytes()) print(bytes(b'abc')) +# make sure empty bytes is converted correctly +print(str(bytes(), 'utf-8')) + a = b"123" print(a) print(str(a)) -- cgit v1.2.3