Merge branch 'master' of github.com:micropython/micropython

py/binary.c

@@ -77,6 +77,52 @@ mp_obj_t mp_binary_get_val(char typecode, void *p, int index) {
     return MP_OBJ_NEW_SMALL_INT(val);
 }
 
+mp_obj_t mp_binary_get_val_unaligned_le(char typecode, byte **ptr) {
+    machine_int_t val = 0;
+    byte *p = *ptr;
+    switch (typecode) {
+        case 'b':
+            val = (int8_t)*p++;
+            break;
+        case BYTEARRAY_TYPECODE:
+        case 'B':
+            val = *p++;
+            break;
+        case 'h':
+            val = (int16_t)((p[1] << 8) | p[0]);
+            break;
+        case 'H':
+            val = (p[1] << 8) | p[0];
+            break;
+        case 'i':
+        case 'l':
+            val = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
+            *ptr = p + 4;
+            return mp_obj_new_int(val);
+        case 'I':
+        case 'L':
+            val = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
+            *ptr = p + 4;
+            return mp_obj_new_int_from_uint(val);
+#if 0 //TODO
+#if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
+        case 'q':
+        case 'Q':
+            // TODO: Explode API more to cover signedness
+            return mp_obj_new_int_from_ll(((long long*)p)[index]);
+#endif
+#if MICROPY_ENABLE_FLOAT
+        case 'f':
+            return mp_obj_new_float(((float*)p)[index]);
+        case 'd':
+            return mp_obj_new_float(((double*)p)[index]);
+#endif
+#endif
+    }
+    *ptr = p;
+    return MP_OBJ_NEW_SMALL_INT(val);
+}
+
 void mp_binary_set_val(char typecode, void *p, int index, mp_obj_t val_in) {
     machine_int_t val = 0;
     if (MP_OBJ_IS_INT(val_in)) {

py/binary.h

@@ -4,4 +4,5 @@
 
 int mp_binary_get_size(char typecode);
 mp_obj_t mp_binary_get_val(char typecode, void *p, int index);
+mp_obj_t mp_binary_get_val_unaligned_le(char typecode, byte **ptr);
 void mp_binary_set_val(char typecode, void *p, int index, mp_obj_t val_in);

py/builtin.h

@@ -41,3 +41,4 @@ extern const mp_obj_module_t mp_module_collections;
 extern const mp_obj_module_t mp_module_io;
 extern const mp_obj_module_t mp_module_math;
 extern const mp_obj_module_t mp_module_micropython;
+extern const mp_obj_module_t mp_module_struct;

py/builtintables.c

@@ -127,6 +127,9 @@ STATIC const mp_map_elem_t mp_builtin_module_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_io), (mp_obj_t)&mp_module_io },
 #endif
     { MP_OBJ_NEW_QSTR(MP_QSTR_collections), (mp_obj_t)&mp_module_collections },
+#if MICROPY_ENABLE_MOD_STRUCT
+    { MP_OBJ_NEW_QSTR(MP_QSTR_struct), (mp_obj_t)&mp_module_struct },
+#endif
 
 #if MICROPY_ENABLE_FLOAT
     { MP_OBJ_NEW_QSTR(MP_QSTR_math), (mp_obj_t)&mp_module_math },

py/makeqstrdata.py

@@ -29,6 +29,7 @@ def do_work(infiles):
     for infile in infiles:
         with open(infile, 'rt') as f:
             line_number = 0
+            conditional = None
             for line in f:
                 line_number += 1
                 line = line.strip()
@@ -37,6 +38,18 @@ def do_work(infiles):
                 if len(line) == 0 or line.startswith('//'):
                     continue
 
+                if line[0] == '#':
+                    if conditional == "<endif>":
+                        assert line == "#endif"
+                        conditional = None
+                    else:
+                        assert conditional is None
+                        conditional = line
+                    continue
+
+                if conditional == "<endif>":
+                    assert False, "#endif expected before '%s'" % line
+
                 # verify line is of the correct form
                 match = re.match(r'Q\((.+)\)$', line)
                 if not match:
@@ -52,15 +65,21 @@ def do_work(infiles):
                     continue
 
                 # add the qstr to the list, with order number to retain original order in file
-                qstrs[ident] = (len(qstrs), ident, qstr)
+                qstrs[ident] = (len(qstrs), ident, qstr, conditional)
+                if conditional is not None:
+                    conditional = "<endif>"
 
     # process the qstrs, printing out the generated C header file
     print('// This file was automatically generated by makeqstrdata.py')
     print('')
-    for order, ident, qstr in sorted(qstrs.values(), key=lambda x: x[0]):
+    for order, ident, qstr, conditional in sorted(qstrs.values(), key=lambda x: x[0]):
         qhash = compute_hash(qstr)
         qlen = len(qstr)
+        if conditional:
+            print(conditional)
         print('Q({}, (const byte*)"\\x{:02x}\\x{:02x}\\x{:02x}\\x{:02x}" "{}")'.format(ident, qhash & 0xff, (qhash >> 8) & 0xff, qlen & 0xff, (qlen >> 8) & 0xff, qstr))
+        if conditional:
+            print('#endif')
 
     return True
 

py/modstruct.c

+#include <assert.h>
+#include <string.h>
+#include "misc.h"
+#include "mpconfig.h"
+#include "qstr.h"
+#include "obj.h"
+#include "builtin.h"
+#include "objtuple.h"
+#include "binary.h"
+
+#if MICROPY_ENABLE_MOD_STRUCT
+
+STATIC char get_fmt_type(const char **fmt) {
+    char t = **fmt;
+    switch (t) {
+        case '!':
+            t = '>';
+            break;
+        case '@':
+        case '=':
+        case '<':
+        case '>':
+            break;
+        default:
+            return '@';
+    }
+    // Skip type char
+    (*fmt)++;
+    return t;
+}
+
+STATIC uint calcsize_items(const char *fmt) {
+    // TODO
+    return strlen(fmt);
+}
+
+STATIC mp_obj_t struct_calcsize(mp_obj_t fmt_in) {
+    const char *fmt = mp_obj_str_get_str(fmt_in);
+    char fmt_type = get_fmt_type(&fmt);
+    assert(fmt_type == '<'); (void)fmt_type;
+    uint size;
+    for (size = 0; *fmt; fmt++) {
+        int sz = mp_binary_get_size(*fmt);
+        // TODO
+        assert(sz != -1);
+        size += sz;
+    }
+    return MP_OBJ_NEW_SMALL_INT(size);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(struct_calcsize_obj, struct_calcsize);
+
+STATIC mp_obj_t struct_unpack(mp_obj_t fmt_in, mp_obj_t data_in) {
+    // TODO: "The buffer must contain exactly the amount of data required by the format (len(bytes) must equal calcsize(fmt))."
+    const char *fmt = mp_obj_str_get_str(fmt_in);
+    char fmt_type = get_fmt_type(&fmt);
+    assert(fmt_type == '<'); (void)fmt_type;
+    uint size = calcsize_items(fmt);
+    mp_obj_tuple_t *res = mp_obj_new_tuple(size, NULL);
+    buffer_info_t bufinfo;
+    mp_get_buffer_raise(data_in, &bufinfo);
+    byte *p = bufinfo.buf;
+
+    for (uint i = 0; i < size; i++) {
+        mp_obj_t item = mp_binary_get_val_unaligned_le(*fmt++, &p);
+        res->items[i] = item;
+    }
+    return res;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(struct_unpack_obj, struct_unpack);
+
+STATIC const mp_map_elem_t mp_module_struct_globals_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_struct) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_calcsize), (mp_obj_t)&struct_calcsize_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_unpack), (mp_obj_t)&struct_unpack_obj },
+};
+
+STATIC const mp_obj_dict_t mp_module_struct_globals = {
+    .base = {&mp_type_dict},
+    .map = {
+        .all_keys_are_qstrs = 1,
+        .table_is_fixed_array = 1,
+        .used = sizeof(mp_module_struct_globals_table) / sizeof(mp_map_elem_t),
+        .alloc = sizeof(mp_module_struct_globals_table) / sizeof(mp_map_elem_t),
+        .table = (mp_map_elem_t*)mp_module_struct_globals_table,
+    },
+};
+
+const mp_obj_module_t mp_module_struct = {
+    .base = { &mp_type_module },
+    .name = MP_QSTR_struct,
+    .globals = (mp_obj_dict_t*)&mp_module_struct_globals,
+};
+
+#endif

py/mpconfig.h

@@ -115,6 +115,11 @@ typedef double mp_float_t;
 #define MICROPY_ENABLE_MOD_IO (1)
 #endif
 
+// Whether to provide "struct" module
+#ifndef MICROPY_ENABLE_MOD_STRUCT
+#define MICROPY_ENABLE_MOD_STRUCT (1)
+#endif
+
 // Whether to support slice object and correspondingly
 // slice subscript operators
 #ifndef MICROPY_ENABLE_SLICE

py/objfun.c

@@ -211,9 +211,13 @@ arg_error:
 }
 
 STATIC mp_obj_t fun_bc_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
-    DEBUG_printf("Input: ");
+    DEBUG_printf("Input n_args: %d, n_kw: %d\n", n_args, n_kw);
+    DEBUG_printf("Input pos args: ");
     dump_args(args, n_args);
+    DEBUG_printf("Input kw args: ");
+    dump_args(args + n_args, n_kw * 2);
     mp_obj_fun_bc_t *self = self_in;
+    DEBUG_printf("Func n_def_args: %d\n", self->n_def_args);
 
     const mp_obj_t *kwargs = args + n_args;
     mp_obj_t *extra_args = self->extra_args + self->n_def_args;
@@ -295,9 +299,9 @@ continue2:;
         // Now fill in defaults
         mp_obj_t *d = &flat_args[self->n_args - 1];
         mp_obj_t *s = &self->extra_args[self->n_def_args - 1];
-        for (int i = self->n_def_args; i > 0; i--) {
+        for (int i = self->n_def_args; i > 0; i--, d--, s--) {
             if (*d == MP_OBJ_NULL) {
-                *d-- = *s--;
+                *d = *s;
             }
         }
         DEBUG_printf("Args after filling defaults: ");

py/objstr.c

@@ -330,6 +330,7 @@ STATIC mp_obj_t str_join(mp_obj_t self_in, mp_obj_t arg) {
     } else {
         if (!MP_OBJ_IS_TYPE(arg, &mp_type_list)) {
             // arg is not a list, try to convert it to one
+            // TODO: Try to optimize?
             arg = mp_type_list.make_new((mp_obj_t)&mp_type_list, 1, 0, &arg);
         }
         mp_obj_list_get(arg, &seq_len, &seq_items);

py/py.mk

@@ -81,6 +81,7 @@ PY_O_BASENAME = \
 	modio.o \
 	modmath.o \
 	modmicropython.o \
+	modstruct.o \
 	vm.o \
 	showbc.o \
 	repl.o \

py/qstrdefs.h

@@ -84,6 +84,9 @@ Q(bool)
 Q(bytearray)
 Q(bytes)
 Q(callable)
+#if MICROPY_ENABLE_MOD_STRUCT
+Q(calcsize)
+#endif
 Q(chr)
 Q(classmethod)
 Q(collections)
@@ -127,10 +130,16 @@ Q(staticmethod)
 Q(sum)
 Q(super)
 Q(str)
+#if MICROPY_ENABLE_MOD_STRUCT
+Q(struct)
+#endif
 Q(sys)
 Q(to_bytes)
 Q(tuple)
 Q(type)
+#if MICROPY_ENABLE_MOD_STRUCT
+Q(unpack)
+#endif
 Q(value)
 Q(zip)
 

tests/basics/fun-defargs2.py

@@ -11,3 +11,9 @@ foo(1, b=333)
 
 # override with keyword
 foo(a=2, b=333)
+
+def foo2(a=1, b=2):
+    print(a, b)
+
+# default and keyword
+foo2(b='two')

tests/basics/struct1.py

+import struct
+print(struct.calcsize("<bI"))
+print(struct.unpack("<bI", b"\x80\0\0\x01\0"))