Commit e9db8404 authored by Paul Sokolovsky's avatar Paul Sokolovsky
Browse files

py: Start implementing "struct" module.

Only calcsize() and unpack() functions provided so far, for little-endian
byte order. Format strings don't support repition spec (like "2b3i").

Unfortunately, dealing with all the various binary type sizes and alignments
will lead to quite a bloated "binary" helper functions  - if optimizing for
speed. Need to think if using dynamic parametrized algos makes more sense.
parent acb133d1
......@@ -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)) {
......
......@@ -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);
......@@ -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;
......@@ -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 },
......
#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
......@@ -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
......
......@@ -81,6 +81,7 @@ PY_O_BASENAME = \
modio.o \
modmath.o \
modmicropython.o \
modstruct.o \
vm.o \
showbc.o \
repl.o \
......
......@@ -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)
......
import struct
print(struct.calcsize("<bI"))
print(struct.unpack("<bI", b"\x80\0\0\x01\0"))
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment