jebbatime
/
micropython
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

nlr-macros
Damien George 2014-06-25 04:10:34 +01:00
parent 780e54cdc3 939c2e7f44
commit e973acde81
100 changed files with 500 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bare-arm/Makefile
View File

@ -13,7 +13,7 @@ INC += -I$(PY_SRC)
INC += -I$(BUILD)
CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -mabi=aapcs-linux -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -fsingle-precision-constant -Wdouble-promotion
CFLAGS = $(INC) -Wall -Werror -ansi -std=gnu99 $(CFLAGS_CORTEX_M4) $(COPT)
CFLAGS = $(INC) -Wall -Werror -ansi -std=gnu99 -nostdlib $(CFLAGS_CORTEX_M4) $(COPT)
#Debugging/Optimization
ifeq ($(DEBUG), 1)
@ -22,7 +22,7 @@ else
CFLAGS += -Os -DNDEBUG
endif
LDFLAGS = --nostdlib -T stm32f405.ld
LDFLAGS = -nostdlib -T stm32f405.ld
LIBS =
SRC_C = \

2
py/asmthumb.c
View File

@ -28,8 +28,8 @@
#include <assert.h>
#include <string.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "asmthumb.h"
// wrapper around everything in this file

2
py/asmx64.c
View File

@ -29,8 +29,8 @@
#include <assert.h>
#include <string.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
// wrapper around everything in this file
#if MICROPY_EMIT_X64

2
py/binary.c
View File

@ -29,8 +29,8 @@
#include <string.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "binary.h"

4
py/builtin.c
View File

@ -113,10 +113,12 @@ mp_obj_t mp_builtin_abs(mp_obj_t o_in) {
} 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
} else {
assert(0);
@ -154,7 +156,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_any_obj, mp_builtin_any);
STATIC mp_obj_t mp_builtin_bin(mp_obj_t o_in) {
mp_obj_t args[] = { MP_OBJ_NEW_QSTR(MP_QSTR__brace_open__colon__hash_b_brace_close_), o_in };
return mp_obj_str_format(ARRAY_SIZE(args), args);
return mp_obj_str_format(MP_ARRAY_SIZE(args), args);
}
MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_bin_obj, mp_builtin_bin);

12
py/builtintables.c
View File

@ -26,8 +26,8 @@
#include <stdlib.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "builtin.h"
@ -44,7 +44,7 @@ STATIC const mp_map_elem_t mp_builtin_object_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR_bool), (mp_obj_t)&mp_type_bool },
{ MP_OBJ_NEW_QSTR(MP_QSTR_bytes), (mp_obj_t)&mp_type_bytes },
{ MP_OBJ_NEW_QSTR(MP_QSTR_bytearray), (mp_obj_t)&mp_type_bytearray },
#if MICROPY_PY_BUILTINS_FLOAT
#if MICROPY_PY_BUILTINS_COMPLEX
{ MP_OBJ_NEW_QSTR(MP_QSTR_complex), (mp_obj_t)&mp_type_complex },
#endif
{ MP_OBJ_NEW_QSTR(MP_QSTR_dict), (mp_obj_t)&mp_type_dict },
@ -150,8 +150,8 @@ const mp_obj_dict_t mp_builtin_object_dict_obj = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_builtin_object_table),
.alloc = ARRAY_SIZE(mp_builtin_object_table),
.used = MP_ARRAY_SIZE(mp_builtin_object_table),
.alloc = MP_ARRAY_SIZE(mp_builtin_object_table),
.table = (mp_map_elem_t*)mp_builtin_object_table,
},
};
@ -195,8 +195,8 @@ const mp_obj_dict_t mp_builtin_module_dict_obj = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_builtin_module_table),
.alloc = ARRAY_SIZE(mp_builtin_module_table),
.used = MP_ARRAY_SIZE(mp_builtin_module_table),
.alloc = MP_ARRAY_SIZE(mp_builtin_module_table),
.table = (mp_map_elem_t*)mp_builtin_module_table,
},
};

6
py/compile.c
View File

@ -31,8 +31,8 @@
#include <assert.h>
#include <math.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"
#include "parse.h"
@ -111,8 +111,8 @@ STATIC const mp_map_elem_t mp_constants_table[] = {
STATIC const mp_map_t mp_constants_map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_constants_table),
.alloc = ARRAY_SIZE(mp_constants_table),
.used = MP_ARRAY_SIZE(mp_constants_table),
.alloc = MP_ARRAY_SIZE(mp_constants_table),
.table = (mp_map_elem_t*)mp_constants_table,
};

2
py/emitbc.c
View File

@ -30,8 +30,8 @@
#include <string.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"
#include "parse.h"

2
py/emitcommon.c
View File

@ -28,8 +28,8 @@
#include <stdint.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"
#include "parse.h"

2
py/emitcpy.c
View File

@ -30,8 +30,8 @@
#include <string.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"
#include "parse.h"

2
py/emitglue.c
View File

@ -30,8 +30,8 @@
#include <string.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "runtime0.h"

6
py/emitinlinethumb.c
View File

@ -30,8 +30,8 @@
#include <stdarg.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"
#include "parse.h"
@ -167,7 +167,7 @@ STATIC uint get_arg_reg(emit_inline_asm_t *emit, const char *op, mp_parse_node_t
if (MP_PARSE_NODE_IS_ID(pn)) {
qstr reg_qstr = MP_PARSE_NODE_LEAF_ARG(pn);
const char *reg_str = qstr_str(reg_qstr);
for (uint i = 0; i < ARRAY_SIZE(reg_name_table); i++) {
for (uint i = 0; i < MP_ARRAY_SIZE(reg_name_table); i++) {
const reg_name_t *r = &reg_name_table[i];
if (reg_str[0] == r->name[0] && reg_str[1] == r->name[1] && reg_str[2] == r->name[2] && (reg_str[2] == '\0' || reg_str[3] == '\0')) {
if (r->reg > max_reg) {
@ -286,7 +286,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, int n_args, m
asm_thumb_b_n(emit->as, label_num);
} else if (op_str[0] == 'b' && op_len == 3) {
uint cc = -1;
for (uint i = 0; i < ARRAY_SIZE(cc_name_table); i++) {
for (uint i = 0; i < MP_ARRAY_SIZE(cc_name_table); i++) {
if (op_str[1] == cc_name_table[i].name[0] && op_str[2] == cc_name_table[i].name[1]) {
cc = cc_name_table[i].cc;
}

2
py/emitnative.c
View File

@ -48,8 +48,8 @@
#include <string.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"
#include "parse.h"

2
py/emitpass1.c
View File

@ -28,8 +28,8 @@
#include <stdint.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"
#include "parse.h"

8
py/gc.c
View File

@ -33,7 +33,6 @@
#include "misc.h"
#include "gc.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "runtime.h"
@ -113,7 +112,7 @@ STATIC machine_uint_t gc_lock_depth;
void gc_init(void *start, void *end) {
// align end pointer on block boundary
end = (void*)((machine_uint_t)end & (~(BYTES_PER_BLOCK - 1)));
DEBUG_printf("Initializing GC heap: %p..%p = " UINT_FMT " bytes\n", start, end, end - start);
DEBUG_printf("Initializing GC heap: %p..%p = " UINT_FMT " bytes\n", start, end, (byte*)end - (byte*)start);
// calculate parameters for GC (T=total, A=alloc table, F=finaliser table, P=pool; all in bytes):
// T = A + F + P
@ -268,6 +267,7 @@ STATIC void gc_sweep(void) {
case AT_TAIL:
if (free_tail) {
DEBUG_printf("gc_sweep(%p)\n",PTR_FROM_BLOCK(block));
ATB_ANY_TO_FREE(block);
}
break;
@ -401,6 +401,7 @@ found:
// get pointer to first block
void *ret_ptr = (void*)(gc_pool_start + start_block * WORDS_PER_BLOCK);
DEBUG_printf("gc_alloc(%p)\n", ret_ptr);
// zero out the additional bytes of the newly allocated blocks
// This is needed because the blocks may have previously held pointers
@ -439,6 +440,7 @@ void gc_free(void *ptr_in) {
}
machine_uint_t ptr = (machine_uint_t)ptr_in;
DEBUG_printf("gc_free(%p)\n", ptr);
if (VERIFY_PTR(ptr)) {
machine_uint_t block = BLOCK_FROM_PTR(ptr);
@ -590,7 +592,7 @@ void *gc_realloc(void *ptr_in, machine_uint_t n_bytes) {
return NULL;
}
DEBUG_printf("gc_realloc: allocating new block\n");
DEBUG_printf("gc_realloc(%p -> %p)\n", ptr_in, ptr_out);
memcpy(ptr_out, ptr_in, n_blocks * BYTES_PER_BLOCK);
gc_free(ptr_in);
return ptr_out;

8
py/lexer.c
View File

@ -32,8 +32,8 @@
#include <stdio.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"
@ -694,10 +694,10 @@ STATIC void mp_lexer_next_token_into(mp_lexer_t *lex, mp_token_t *tok, bool firs
// need to check for this special token in many places in the compiler.
// TODO improve speed of these string comparisons
//for (int i = 0; tok_kw[i] != NULL; i++) {
for (int i = 0; i < ARRAY_SIZE(tok_kw); i++) {
for (int i = 0; i < MP_ARRAY_SIZE(tok_kw); i++) {
if (str_strn_equal(tok_kw[i], tok->str, tok->len)) {
if (i == ARRAY_SIZE(tok_kw) - 1) {
// tok_kw[ARRAY_SIZE(tok_kw) - 1] == "__debug__"
if (i == MP_ARRAY_SIZE(tok_kw) - 1) {
// tok_kw[MP_ARRAY_SIZE(tok_kw) - 1] == "__debug__"
tok->kind = (mp_optimise_value == 0 ? MP_TOKEN_KW_TRUE : MP_TOKEN_KW_FALSE);
} else {
tok->kind = MP_TOKEN_KW_FALSE + i;

2
py/lexerstr.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"

2
py/lexerunix.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#if MICROPY_HELPER_LEXER_UNIX

2
py/malloc.c
View File

@ -28,8 +28,8 @@
#include <stdlib.h>
#include <string.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#if 0 // print debugging info
#define DEBUG_printf DEBUG_printf

2
py/map.c
View File

@ -27,8 +27,8 @@
#include <stdlib.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "runtime0.h"

2
py/misc.h
View File

@ -82,7 +82,7 @@ int m_get_peak_bytes_allocated(void);
/** array helpers ***********************************************/
// get the number of elements in a fixed-size array
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
#define MP_ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
/** unichar / UTF-8 *********************************************/

4
py/mkrules.mk
View File

@ -73,9 +73,9 @@ all: $(PROG)
$(PROG): $(OBJ)
$(ECHO) "LINK $@"
$(Q)$(CC) -o $@ $(OBJ) $(LIB) $(LDFLAGS)
$(Q)$(CC) $(COPT) -o $@ $(OBJ) $(LIB) $(LDFLAGS)
ifndef DEBUG
$(Q)$(STRIP) $(PROG)
$(Q)$(STRIP) $(STRIPFLAGS_EXTRA) $(PROG)
endif
$(Q)$(SIZE) $(PROG)

6
py/modarray.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "builtin.h"
@ -40,8 +40,8 @@ STATIC const mp_obj_dict_t mp_module_array_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_array_globals_table),
.alloc = ARRAY_SIZE(mp_module_array_globals_table),
.used = MP_ARRAY_SIZE(mp_module_array_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_array_globals_table),
.table = (mp_map_elem_t*)mp_module_array_globals_table,
},
};

6
py/modcmath.c
View File

@ -26,8 +26,8 @@
#include <math.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "builtin.h"
@ -142,8 +142,8 @@ STATIC const mp_obj_dict_t mp_module_cmath_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_cmath_globals_table),
.alloc = ARRAY_SIZE(mp_module_cmath_globals_table),
.used = MP_ARRAY_SIZE(mp_module_cmath_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_cmath_globals_table),
.table = (mp_map_elem_t*)mp_module_cmath_globals_table,
},
};

6
py/modcollections.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "builtin.h"
@ -42,8 +42,8 @@ STATIC const mp_obj_dict_t mp_module_collections_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_collections_globals_table),
.alloc = ARRAY_SIZE(mp_module_collections_globals_table),
.used = MP_ARRAY_SIZE(mp_module_collections_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_collections_globals_table),
.table = (mp_map_elem_t*)mp_module_collections_globals_table,
},
};

6
py/modgc.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "builtin.h"
@ -73,8 +73,8 @@ STATIC const mp_obj_dict_t mp_module_gc_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_gc_globals_table),
.alloc = ARRAY_SIZE(mp_module_gc_globals_table),
.used = MP_ARRAY_SIZE(mp_module_gc_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_gc_globals_table),
.table = (mp_map_elem_t*)mp_module_gc_globals_table,
},
};

6
py/modio.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "builtin.h"
@ -57,8 +57,8 @@ STATIC const mp_obj_dict_t mp_module_io_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_io_globals_table),
.alloc = ARRAY_SIZE(mp_module_io_globals_table),
.used = MP_ARRAY_SIZE(mp_module_io_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_io_globals_table),
.table = (mp_map_elem_t*)mp_module_io_globals_table,
},
};

6
py/modmath.c
View File

@ -26,8 +26,8 @@
#include <math.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "builtin.h"
@ -172,8 +172,8 @@ STATIC const mp_obj_dict_t mp_module_math_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_math_globals_table),
.alloc = ARRAY_SIZE(mp_module_math_globals_table),
.used = MP_ARRAY_SIZE(mp_module_math_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_math_globals_table),
.table = (mp_map_elem_t*)mp_module_math_globals_table,
},
};

6
py/modmicropython.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "builtin.h"
@ -65,8 +65,8 @@ STATIC const mp_obj_dict_t mp_module_micropython_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_micropython_globals_table),
.alloc = ARRAY_SIZE(mp_module_micropython_globals_table),
.used = MP_ARRAY_SIZE(mp_module_micropython_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_micropython_globals_table),
.table = (mp_map_elem_t*)mp_module_micropython_globals_table,
},
};

6
py/modstruct.c
View File

@ -27,8 +27,8 @@
#include <assert.h>
#include <string.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "builtin.h"
@ -210,8 +210,8 @@ STATIC const mp_obj_dict_t mp_module_struct_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_struct_globals_table),
.alloc = ARRAY_SIZE(mp_module_struct_globals_table),
.used = MP_ARRAY_SIZE(mp_module_struct_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_struct_globals_table),
.table = (mp_map_elem_t*)mp_module_struct_globals_table,
},
};

6
py/modsys.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "builtin.h"
@ -87,8 +87,8 @@ STATIC const mp_obj_dict_t mp_module_sys_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_sys_globals_table),
.alloc = ARRAY_SIZE(mp_module_sys_globals_table),
.used = MP_ARRAY_SIZE(mp_module_sys_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_sys_globals_table),
.table = (mp_map_elem_t*)mp_module_sys_globals_table,
},
};

4
py/mpconfig.h
View File

@ -223,6 +223,10 @@ typedef double mp_float_t;
#define MICROPY_PY_BUILTINS_FLOAT (0)
#endif
#ifndef MICROPY_PY_BUILTINS_COMPLEX
#define MICROPY_PY_BUILTINS_COMPLEX (MICROPY_PY_BUILTINS_FLOAT)
#endif
// Enable features which improve CPython compatibility
// but may lead to more code size/memory usage.
// TODO: Originally intended as generic category to not

2
py/mpz.c
View File

@ -30,8 +30,8 @@
#include <string.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "mpz.h"
#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_MPZ

3
py/nlr.h
View File

@ -29,6 +29,7 @@
#include <limits.h>
#include <setjmp.h>
#include <assert.h>
typedef struct _nlr_buf_t nlr_buf_t;
struct _nlr_buf_t {
@ -44,7 +45,7 @@ struct _nlr_buf_t {
#else
void *regs[8];
#endif
#elif defined(__thumb2__)
#elif defined(__thumb2__) || defined(__thumb__) || defined(__arm__)
void *regs[10];
#else
#define MICROPY_NLR_SETJMP (1)

12
py/nlrthumb.S
View File

@ -24,19 +24,21 @@
* THE SOFTWARE.
*/
#if defined(__thumb2__) && !MICROPY_NLR_SETJMP
/* thumb callee save: bx, bp, sp, r12, r14, r14, r15 */
#if !MICROPY_NLR_SETJMP && (defined(__thumb2__) || defined(__thumb__) || defined(__arm__))
/* arm callee save: bx, bp, sp, r12, r14, r14, r15 */
.syntax unified
/*.cpu cortex-m4*/
.thumb
/*.thumb*/
.text
.align 2
/* uint nlr_push(r0=nlr_buf_t *nlr) */
.global nlr_push
#if defined(__thumb2__)
.thumb
.thumb_func
#endif
.type nlr_push, %function
nlr_push:
str lr, [r0, #8] @ store lr into nlr_buf
@ -64,8 +66,10 @@ nlr_push:
@ void nlr_pop()
.global nlr_pop
#if defined(__thumb2__)
.thumb
.thumb_func
#endif
.type nlr_pop, %function
nlr_pop:
ldr r3, .L5 @ load addr of nlr_top
@ -80,8 +84,10 @@ nlr_pop:
/* void nlr_jump(r0=uint val) */
.global nlr_jump
#if defined(__thumb2__)
.thumb
.thumb_func
#endif
.type nlr_jump, %function
nlr_jump:
ldr r3, .L2 @ load addr of nlr_top

2
py/obj.c
View File

@ -274,6 +274,7 @@ mp_float_t mp_obj_get_float(mp_obj_t arg) {
}
}
#if MICROPY_PY_BUILTINS_COMPLEX
void mp_obj_get_complex(mp_obj_t arg, mp_float_t *real, mp_float_t *imag) {
if (arg == mp_const_false) {
*real = 0;
@ -297,6 +298,7 @@ void mp_obj_get_complex(mp_obj_t arg, mp_float_t *real, mp_float_t *imag) {
}
}
#endif
#endif
void mp_obj_get_array(mp_obj_t o, uint *len, mp_obj_t **items) {
if (MP_OBJ_IS_TYPE(o, &mp_type_tuple)) {

2
py/objcomplex.c
View File

@ -36,7 +36,7 @@
#include "runtime0.h"
#include "runtime.h"
#if MICROPY_PY_BUILTINS_FLOAT
#if MICROPY_PY_BUILTINS_COMPLEX
#include <math.h>

4
py/objenumerate.c
View File

@ -27,8 +27,8 @@
#include <stdlib.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "runtime.h"
@ -45,7 +45,7 @@ STATIC const mp_arg_t enumerate_make_new_args[] = {
{ MP_QSTR_iterable, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_start, MP_ARG_INT, {.u_int = 0} },
};
#define ENUMERATE_MAKE_NEW_NUM_ARGS ARRAY_SIZE(enumerate_make_new_args)
#define ENUMERATE_MAKE_NEW_NUM_ARGS MP_ARRAY_SIZE(enumerate_make_new_args)
STATIC mp_obj_t enumerate_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
#if MICROPY_CPYTHON_COMPAT

5
py/objfloat.c
View File

@ -102,9 +102,12 @@ STATIC mp_obj_t float_unary_op(int op, mp_obj_t o_in) {
STATIC mp_obj_t float_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
mp_obj_float_t *lhs = lhs_in;
#if MICROPY_PY_BUILTINS_COMPLEX
if (MP_OBJ_IS_TYPE(rhs_in, &mp_type_complex)) {
return mp_obj_complex_binary_op(op, lhs->value, 0, rhs_in);
} else {
} else
#endif
{
return mp_obj_float_binary_op(op, lhs->value, rhs_in);
}
}

2
py/objint_mpz.c
View File

@ -121,8 +121,10 @@ mp_obj_t mp_obj_int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
#if MICROPY_PY_BUILTINS_FLOAT
} else if (MP_OBJ_IS_TYPE(rhs_in, &mp_type_float)) {
return mp_obj_float_binary_op(op, mpz_as_float(zlhs), rhs_in);
#if MICROPY_PY_BUILTINS_COMPLEX
} else if (MP_OBJ_IS_TYPE(rhs_in, &mp_type_complex)) {
return mp_obj_complex_binary_op(op, mpz_as_float(zlhs), 0, rhs_in);
#endif
#endif
} else {
// delegate to generic function to check for extra cases

2
py/parse.c
View File

@ -30,8 +30,8 @@
#include <assert.h>
#include <string.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"
#include "parsenumbase.h"

2
py/parsehelper.c
View File

@ -29,8 +29,8 @@
#include <stdint.h>
#include <stdio.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "lexer.h"
#include "parse.h"

8
py/parsenum.c
View File

@ -27,14 +27,15 @@
#include <stdbool.h>
#include <stdlib.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "nlr.h"
#include "obj.h"
#include "parsenumbase.h"
#include "parsenum.h"
#include "smallint.h"
#include "runtime.h"
#if MICROPY_PY_BUILTINS_FLOAT
#include <math.h>
@ -252,10 +253,15 @@ mp_obj_t mp_parse_num_decimal(const char *str, uint len, bool allow_imag, bool f
}
// return the object
#if MICROPY_PY_BUILTINS_COMPLEX
if (imag) {
return mp_obj_new_complex(0, dec_val);
} else if (force_complex) {
return mp_obj_new_complex(dec_val, 0);
#else
if (imag || force_complex) {
mp_not_implemented("complex values not supported");
#endif
} else {
return mp_obj_new_float(dec_val);
}

2
py/parsenumbase.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "parsenumbase.h"
// find real radix base, and strip preceding '0x', '0o' and '0b'

2
py/pfenv.c
View File

@ -27,8 +27,8 @@
#include <stdint.h>
#include <string.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "mpz.h"

2
py/qstr.c
View File

@ -27,8 +27,8 @@
#include <assert.h>
#include <string.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
// NOTE: we are using linear arrays to store and search for qstr's (unique strings, interned strings)

2
py/repl.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "repl.h"
#if MICROPY_HELPER_REPL

2
py/runtime.c
View File

@ -426,6 +426,7 @@ mp_obj_t mp_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
} else {
return res;
}
#if MICROPY_PY_BUILTINS_COMPLEX
} else if (MP_OBJ_IS_TYPE(rhs, &mp_type_complex)) {
mp_obj_t res = mp_obj_complex_binary_op(op, lhs_val, 0, rhs);
if (res == MP_OBJ_NULL) {
@ -433,6 +434,7 @@ mp_obj_t mp_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
} else {
return res;
}
#endif
#endif
}
}

2
py/scope.c
View File

@ -29,8 +29,8 @@
#include <stdio.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "parse.h"

2
py/smallint.c
View File

@ -24,8 +24,8 @@
* THE SOFTWARE.
*/
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "smallint.h"

2
py/unicode.c
View File

@ -26,8 +26,8 @@
#include <stdint.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
// attribute flags
#define FL_PRINT (0x01)

2
py/vstr.c
View File

@ -29,8 +29,8 @@
#include <stdarg.h>
#include <string.h>
#include <assert.h>
#include "misc.h"
#include "mpconfig.h"
#include "misc.h"
// returned value is always at least 1 greater than argument
#define ROUND_ALLOC(a) (((a) & ((~0) - 7)) + 8)

4
stmhal/Makefile
View File

@ -41,7 +41,7 @@ INC += -I$(FATFS_DIR)/src
INC += -I$(CC3K_DIR)
CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -mabi=aapcs-linux -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -fsingle-precision-constant -Wdouble-promotion
CFLAGS = $(INC) -Wall -Werror -ansi -std=gnu99 $(CFLAGS_CORTEX_M4) $(COPT)
CFLAGS = $(INC) -Wall -Werror -ansi -std=gnu99 -nostdlib $(CFLAGS_CORTEX_M4) $(COPT)
CFLAGS += -Iboards/$(BOARD)
@ -53,7 +53,7 @@ else
COPT += -Os -DNDEBUG
endif
LDFLAGS = --nostdlib -T stm32f405.ld -Map=$(@:.elf=.map) --cref
LDFLAGS = -nostdlib -T stm32f405.ld -Map=$(@:.elf=.map) --cref
LIBS =
# uncomment this if you want libgcc

2
stmhal/dac.c
View File

@ -237,7 +237,7 @@ STATIC const mp_arg_t pyb_dac_write_timed_args[] = {
{ MP_QSTR_freq, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = DMA_NORMAL} },
};
#define PYB_DAC_WRITE_TIMED_NUM_ARGS ARRAY_SIZE(pyb_dac_write_timed_args)
#define PYB_DAC_WRITE_TIMED_NUM_ARGS MP_ARRAY_SIZE(pyb_dac_write_timed_args)
mp_obj_t pyb_dac_write_timed(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
pyb_dac_obj_t *self = args[0];

2
stmhal/extint.c
View File

@ -296,7 +296,7 @@ STATIC const mp_arg_t pyb_extint_make_new_args[] = {
{ MP_QSTR_pull, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_callback, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
};
#define PYB_EXTINT_MAKE_NEW_NUM_ARGS ARRAY_SIZE(pyb_extint_make_new_args)
#define PYB_EXTINT_MAKE_NEW_NUM_ARGS MP_ARRAY_SIZE(pyb_extint_make_new_args)
STATIC mp_obj_t extint_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
// type_in == extint_obj_type

10
stmhal/i2c.c
View File

@ -220,7 +220,7 @@ STATIC const mp_arg_t pyb_i2c_init_args[] = {
{ MP_QSTR_baudrate, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 400000} },
{ MP_QSTR_gencall, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
};
#define PYB_I2C_INIT_NUM_ARGS ARRAY_SIZE(pyb_i2c_init_args)
#define PYB_I2C_INIT_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_init_args)
STATIC mp_obj_t pyb_i2c_init_helper(const pyb_i2c_obj_t *self, uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
// parse args
@ -271,7 +271,7 @@ STATIC mp_obj_t pyb_i2c_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const
machine_int_t i2c_id = mp_obj_get_int(args[0]) - 1;
// check i2c number
if (!(0 <= i2c_id && i2c_id < ARRAY_SIZE(pyb_i2c_obj) && pyb_i2c_obj[i2c_id].i2c != NULL)) {
if (!(0 <= i2c_id && i2c_id < MP_ARRAY_SIZE(pyb_i2c_obj) && pyb_i2c_obj[i2c_id].i2c != NULL)) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "I2C bus %d does not exist", i2c_id + 1));
}
@ -363,7 +363,7 @@ STATIC const mp_arg_t pyb_i2c_send_args[] = {
{ MP_QSTR_addr, MP_ARG_INT, {.u_int = PYB_I2C_MASTER_ADDRESS} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
};
#define PYB_I2C_SEND_NUM_ARGS ARRAY_SIZE(pyb_i2c_send_args)
#define PYB_I2C_SEND_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_send_args)
STATIC mp_obj_t pyb_i2c_send(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
pyb_i2c_obj_t *self = args[0];
@ -414,7 +414,7 @@ STATIC const mp_arg_t pyb_i2c_recv_args[] = {
{ MP_QSTR_addr, MP_ARG_INT, {.u_int = PYB_I2C_MASTER_ADDRESS} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
};
#define PYB_I2C_RECV_NUM_ARGS ARRAY_SIZE(pyb_i2c_recv_args)
#define PYB_I2C_RECV_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_recv_args)
STATIC mp_obj_t pyb_i2c_recv(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
pyb_i2c_obj_t *self = args[0];
@ -470,7 +470,7 @@ STATIC const mp_arg_t pyb_i2c_mem_read_args[] = {
{ MP_QSTR_memaddr, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
};
#define PYB_I2C_MEM_READ_NUM_ARGS ARRAY_SIZE(pyb_i2c_mem_read_args)
#define PYB_I2C_MEM_READ_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_mem_read_args)
STATIC mp_obj_t pyb_i2c_mem_read(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
pyb_i2c_obj_t *self = args[0];

2
stmhal/led.c
View File

@ -61,7 +61,7 @@ STATIC const pyb_led_obj_t pyb_led_obj[] = {
#endif
#endif
};
#define NUM_LEDS ARRAY_SIZE(pyb_led_obj)
#define NUM_LEDS MP_ARRAY_SIZE(pyb_led_obj)
void led_init(void) {
/* GPIO structure */

2
stmhal/main.c
View File

@ -308,7 +308,7 @@ soft_reset:
MP_OBJ_NEW_SMALL_INT(115200),
};
pyb_uart_global_debug = pyb_uart_type.make_new((mp_obj_t)&pyb_uart_type,
ARRAY_SIZE(args),
MP_ARRAY_SIZE(args),
0, args);
}
#else

4
stmhal/modos.c
View File

@ -194,8 +194,8 @@ STATIC const mp_obj_dict_t os_module_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(os_module_globals_table),
.alloc = ARRAY_SIZE(os_module_globals_table),
.used = MP_ARRAY_SIZE(os_module_globals_table),
.alloc = MP_ARRAY_SIZE(os_module_globals_table),
.table = (mp_map_elem_t*)os_module_globals_table,
},
};

4
stmhal/modpyb.c
View File

@ -426,8 +426,8 @@ STATIC const mp_obj_dict_t pyb_module_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(pyb_module_globals_table),
.alloc = ARRAY_SIZE(pyb_module_globals_table),
.used = MP_ARRAY_SIZE(pyb_module_globals_table),
.alloc = MP_ARRAY_SIZE(pyb_module_globals_table),
.table = (mp_map_elem_t*)pyb_module_globals_table,
},
};

4
stmhal/modstm.c
View File

@ -131,8 +131,8 @@ STATIC const mp_obj_dict_t stm_module_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(stm_module_globals_table),
.alloc = ARRAY_SIZE(stm_module_globals_table),
.used = MP_ARRAY_SIZE(stm_module_globals_table),
.alloc = MP_ARRAY_SIZE(stm_module_globals_table),
.table = (mp_map_elem_t*)stm_module_globals_table,
},
};

4
stmhal/modtime.c
View File

@ -122,8 +122,8 @@ STATIC const mp_obj_dict_t time_module_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(time_module_globals_table),
.alloc = ARRAY_SIZE(time_module_globals_table),
.used = MP_ARRAY_SIZE(time_module_globals_table),
.alloc = MP_ARRAY_SIZE(time_module_globals_table),
.table = (mp_map_elem_t*)time_module_globals_table,
},
};

10
stmhal/spi.c
View File

@ -188,7 +188,7 @@ STATIC const pyb_spi_obj_t pyb_spi_obj[] = {
{{&pyb_spi_type}, NULL},
#endif
};
#define PYB_NUM_SPI ARRAY_SIZE(pyb_spi_obj)
#define PYB_NUM_SPI MP_ARRAY_SIZE(pyb_spi_obj)
STATIC void pyb_spi_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
pyb_spi_obj_t *self = self_in;
@ -242,7 +242,7 @@ STATIC const mp_arg_t pyb_spi_init_args[] = {
{ MP_QSTR_ti, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
{ MP_QSTR_crc, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
};
#define PYB_SPI_INIT_NUM_ARGS ARRAY_SIZE(pyb_spi_init_args)
#define PYB_SPI_INIT_NUM_ARGS MP_ARRAY_SIZE(pyb_spi_init_args)
STATIC mp_obj_t pyb_spi_init_helper(const pyb_spi_obj_t *self, uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
// parse args
@ -359,7 +359,7 @@ STATIC const mp_arg_t pyb_spi_send_args[] = {
{ MP_QSTR_send, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
};
#define PYB_SPI_SEND_NUM_ARGS ARRAY_SIZE(pyb_spi_send_args)
#define PYB_SPI_SEND_NUM_ARGS MP_ARRAY_SIZE(pyb_spi_send_args)
STATIC mp_obj_t pyb_spi_send(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
// TODO assumes transmission size is 8-bits wide
@ -401,7 +401,7 @@ STATIC const mp_arg_t pyb_spi_recv_args[] = {
{ MP_QSTR_recv, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
};
#define PYB_SPI_RECV_NUM_ARGS ARRAY_SIZE(pyb_spi_recv_args)
#define PYB_SPI_RECV_NUM_ARGS MP_ARRAY_SIZE(pyb_spi_recv_args)
STATIC mp_obj_t pyb_spi_recv(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
// TODO assumes transmission size is 8-bits wide
@ -449,7 +449,7 @@ STATIC const mp_arg_t pyb_spi_send_recv_args[] = {
{ MP_QSTR_recv, MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
};
#define PYB_SPI_SEND_RECV_NUM_ARGS ARRAY_SIZE(pyb_spi_send_recv_args)
#define PYB_SPI_SEND_RECV_NUM_ARGS MP_ARRAY_SIZE(pyb_spi_send_recv_args)
STATIC mp_obj_t pyb_spi_send_recv(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
// TODO assumes transmission size is 8-bits wide

4
stmhal/timer.c
View File

@ -105,7 +105,7 @@ static uint32_t tim3_counter = 0;
// Used to do callbacks to Python code on interrupt
STATIC pyb_timer_obj_t *pyb_timer_obj_all[14];
#define PYB_TIMER_OBJ_ALL_NUM ARRAY_SIZE(pyb_timer_obj_all)
#define PYB_TIMER_OBJ_ALL_NUM MP_ARRAY_SIZE(pyb_timer_obj_all)
void timer_init0(void) {
tim3_counter = 0;
@ -234,7 +234,7 @@ STATIC const mp_arg_t pyb_timer_init_args[] = {
{ MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = TIM_COUNTERMODE_UP} },
{ MP_QSTR_div, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = TIM_CLOCKDIVISION_DIV1} },
};
#define PYB_TIMER_INIT_NUM_ARGS ARRAY_SIZE(pyb_timer_init_args)
#define PYB_TIMER_INIT_NUM_ARGS MP_ARRAY_SIZE(pyb_timer_init_args)
STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *self, uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
// parse args

6
stmhal/uart.c
View File

@ -270,7 +270,7 @@ STATIC const mp_arg_t pyb_uart_init_args[] = {
{ MP_QSTR_stop, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
{ MP_QSTR_parity, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
};
#define PYB_UART_INIT_NUM_ARGS ARRAY_SIZE(pyb_uart_init_args)
#define PYB_UART_INIT_NUM_ARGS MP_ARRAY_SIZE(pyb_uart_init_args)
STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
// parse args
@ -396,7 +396,7 @@ STATIC const mp_arg_t pyb_uart_send_args[] = {
{ MP_QSTR_send, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
};
#define PYB_UART_SEND_NUM_ARGS ARRAY_SIZE(pyb_uart_send_args)
#define PYB_UART_SEND_NUM_ARGS MP_ARRAY_SIZE(pyb_uart_send_args)
STATIC mp_obj_t pyb_uart_send(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
// TODO assumes transmission size is 8-bits wide
@ -438,7 +438,7 @@ STATIC const mp_arg_t pyb_uart_recv_args[] = {
{ MP_QSTR_recv, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
};
#define PYB_UART_RECV_NUM_ARGS ARRAY_SIZE(pyb_uart_recv_args)
#define PYB_UART_RECV_NUM_ARGS MP_ARRAY_SIZE(pyb_uart_recv_args)
STATIC mp_obj_t pyb_uart_recv(uint n_args, const mp_obj_t *args, mp_map_t *kw_args) {
// TODO assumes transmission size is 8-bits wide

2
teensy/Makefile
View File

@ -23,7 +23,7 @@ INC += -I$(PY_SRC)
INC += -I$(BUILD)
INC += -I$(CORE_PATH)
CFLAGS = $(INC) -Wall -ansi -std=gnu99 $(CFLAGS_CORTEX_M4)
CFLAGS = $(INC) -Wall -ansi -std=gnu99 -nostdlib $(CFLAGS_CORTEX_M4)
LDFLAGS = -nostdlib -T mk20dx256.ld
LIBS = -L $(COMPILER_PATH)/../lib/gcc/arm-none-eabi/4.7.2/thumb2 -lgcc

12
tests/bench/arrayop-1-list_inplace.py 100644
View File

@ -0,0 +1,12 @@
# Array operation
# Type: list, inplace operation using for. What's good about this
# method is that it doesn't require any extra memory allocation.
import bench
def test(num):
for i in iter(range(num//10000)):
arr = [0] * 1000
for i in range(len(arr)):
arr[i] += 1
bench.run(test)

12
tests/bench/arrayop-2-list_map.py 100644
View File

@ -0,0 +1,12 @@
# Array operation
# Type: list, map() call. This method requires allocation of
# the same amount of memory as original array (to hold result
# array). On the other hand, input array stays intact.
import bench
def test(num):
for i in iter(range(num//10000)):
arr = [0] * 1000
arr2 = list(map(lambda x: x + 1, arr))
bench.run(test)

12
tests/bench/arrayop-3-bytearray_inplace.py 100644
View File

@ -0,0 +1,12 @@
# Array operation
# Type: bytearray, inplace operation using for. What's good about this
# method is that it doesn't require any extra memory allocation.
import bench
def test(num):
for i in iter(range(num//10000)):
arr = bytearray(b"\0" * 1000)
for i in range(len(arr)):
arr[i] += 1
bench.run(test)

12
tests/bench/arrayop-4-bytearray_map.py 100644
View File

@ -0,0 +1,12 @@
# Array operation
# Type: list, map() call. This method requires allocation of
# the same amount of memory as original array (to hold result
# array). On the other hand, input array stays intact.
import bench
def test(num):
for i in iter(range(num//10000)):
arr = bytearray(b"\0" * 1000)
arr2 = bytearray(map(lambda x: x + 1, arr))
bench.run(test)

11
tests/bench/bytebuf-1-inplace.py 100644
View File

@ -0,0 +1,11 @@
# Doing some operation on bytearray
# Inplace - the most memory efficient way
import bench
def test(num):
for i in iter(range(num//10000)):
ba = bytearray(b"\0" * 1000)
for i in range(len(ba)):
ba[i] += 1
bench.run(test)

12
tests/bench/bytebuf-2-join_map_bytes.py 100644
View File

@ -0,0 +1,12 @@
# Doing some operation on bytearray
# Pretty weird way - map bytearray thru function, but make sure that
# function return bytes of size 1, then join them together. Surely,
# this is slowest way to do it.
import bench
def test(num):
for i in iter(range(num//10000)):
ba = bytearray(b"\0" * 1000)
ba2 = b''.join(map(lambda x:bytes([x + 1]), ba))
bench.run(test)

10
tests/bench/bytebuf-3-bytarray_map.py 100644
View File

@ -0,0 +1,10 @@
# Doing some operation on bytearray
# No joins, but still map().
import bench
def test(num):
for i in iter(range(num//10000)):
ba = bytearray(b"\0" * 1000)
ba2 = bytearray(map(lambda x: x + 1, ba))
bench.run(test)

8
tests/bench/from_iter-1-list_bound.py 100644
View File

@ -0,0 +1,8 @@
import bench
def test(num):
for i in iter(range(num//10000)):
l = [0] * 1000
l2 = list(l)
bench.run(test)

8
tests/bench/from_iter-2-list_unbound.py 100644
View File

@ -0,0 +1,8 @@
import bench
def test(num):
for i in iter(range(num//10000)):
l = [0] * 1000
l2 = list(map(lambda x: x, l))
bench.run(test)

8
tests/bench/from_iter-3-tuple_bound.py 100644
View File

@ -0,0 +1,8 @@
import bench
def test(num):
for i in iter(range(num//10000)):
l = [0] * 1000
l2 = tuple(l)
bench.run(test)

8
tests/bench/from_iter-4-tuple_unbound.py 100644
View File

@ -0,0 +1,8 @@
import bench
def test(num):
for i in iter(range(num//10000)):
l = [0] * 1000
l2 = tuple(map(lambda x: x, l))
bench.run(test)

8
tests/bench/from_iter-5-bytes_bound.py 100644
View File

@ -0,0 +1,8 @@
import bench
def test(num):
for i in iter(range(num//10000)):
l = [0] * 1000
l2 = bytes(l)
bench.run(test)

8
tests/bench/from_iter-6-bytes_unbound.py 100644
View File

@ -0,0 +1,8 @@
import bench
def test(num):
for i in iter(range(num//10000)):
l = [0] * 1000
l2 = bytes(map(lambda x: x, l))
bench.run(test)

8
tests/bench/from_iter-7-bytearray_bound.py 100644
View File

@ -0,0 +1,8 @@
import bench
def test(num):
for i in iter(range(num//10000)):
l = [0] * 1000
l2 = bytearray(l)
bench.run(test)

8
tests/bench/from_iter-8-bytearray_unbound.py 100644
View File

@ -0,0 +1,8 @@
import bench
def test(num):
for i in iter(range(num//10000)):
l = [0] * 1000
l2 = bytearray(map(lambda x: x, l))
bench.run(test)

9
tests/bench/funcall-1-inline.py 100644
View File

@ -0,0 +1,9 @@
# Function call overhead test
# Establish a baseline for performing a trivial operation inline
import bench
def test(num):
for i in iter(range(num)):
a = i + 1
bench.run(test)

12
tests/bench/funcall-2-funcall.py 100644
View File

@ -0,0 +1,12 @@
# Function call overhead test
# Perform the same trivial operation as global function call
import bench
def f(x):
return x + 1
def test(num):
for i in iter(range(num)):
a = f(i)
bench.run(test)

16
tests/bench/funcall-3-funcall-local.py 100644
View File

@ -0,0 +1,16 @@
# Function call overhead test
# Perform the same trivial operation as calling function, cached in a
# local variable. This is commonly known optimization for overly dynamic
# languages (the idea is to cut on symbolic look up overhead, as local
# variables are accessed by offset, not by name)
import bench
def f(x):
return x + 1
def test(num):
f_ = f
for i in iter(range(num)):
a = f_(i)
bench.run(test)

7
tests/float/math-fun-bool.py
View File

@ -1,6 +1,11 @@
# Test the bool functions from math
from math import isfinite, isnan, isinf
try:
from math import isfinite, isnan, isinf
except ImportError:
print("SKIP")
import sys
sys.exit()
test_values = [1, 0, -1, 1.0, 0.0, -1.0, float('NaN'), float('Inf'),
-float('NaN'), -float('Inf')]

7
tests/float/math-fun.py
View File

@ -1,6 +1,11 @@
# Tests the functions imported from math
from math import *
try:
from math import *
except ImportError:
print("SKIP")
import sys
sys.exit()
test_values = [-100., -1.23456, -1, -0.5, 0.0, 0.5, 1.23456, 100.]
p_test_values = [0.1, 0.5, 1.23456]

32
unix/Makefile
View File

@ -7,6 +7,9 @@ PROG = micropython
# qstr definitions (must come before including py.mk)
QSTR_DEFS = qstrdefsport.h
# OS name, for simple autoconfig
UNAME_S := $(shell uname -s)
# include py core make definitions
include ../py/py.mk
@ -15,14 +18,18 @@ INC += -I$(PY_SRC)
INC += -I$(BUILD)
# compiler settings
CFLAGS = $(INC) -Wall -Werror -ansi -std=gnu99 -DUNIX $(CFLAGS_MOD) $(COPT)
CWARN = -Wall -Werror -Wno-error=cpp
CFLAGS = $(INC) $(CWARN) -ansi -std=gnu99 -DUNIX $(CFLAGS_MOD) $(COPT) $(CFLAGS_EXTRA)
UNAME_S := $(shell uname -s)
ifeq ($(UNAME_S),Darwin)
LDFLAGS = $(LDFLAGS_MOD) -lm -Wl,-map,$@.map,-order_file,$(BUILD)/order.def
else
LDFLAGS = $(LDFLAGS_MOD) -lm -Wl,-Map=$@.map,--cref
endif
# Debugging/Optimization
ifdef DEBUG
CFLAGS += -g
COPT = -O0
else
COPT = -Os #-DNDEBUG
endif
LDFLAGS = $(LDFLAGS_MOD) -lm -Wl,-Map=$@.map,--cref $(LDFLAGS_EXTRA)
ifeq ($(MICROPY_FORCE_32BIT),1)
CFLAGS += -m32
@ -56,14 +63,6 @@ SRC_MOD += modffi.c
endif
# Debugging/Optimization
ifdef DEBUG
CFLAGS += -g
COPT = -O0
else
COPT = -Os #-DNDEBUG
endif
# source files
SRC_C = \
main.c \
@ -75,6 +74,9 @@ SRC_C = \
$(SRC_MOD)
ifeq ($(UNAME_S),Darwin)
LDFLAGS+ = -Wl,-order_file,$(BUILD)/order.def
# Must be the last file in list of sources
SRC_C += seg_helpers.c

10
unix/gccollect.c
View File

@ -97,7 +97,7 @@ void gc_helper_get_regs(regs_t arr) {
}
#endif
#ifdef __thumb2__
#if defined(__thumb2__) || defined(__thumb__) || defined(__arm__)
typedef machine_uint_t regs_t[10];
void gc_helper_get_regs(regs_t arr) {
@ -130,8 +130,11 @@ void gc_collect(void) {
gc_collect_start();
// this traces the .bss section
#ifdef __CYGWIN__
#if defined( __CYGWIN__ )
#define BSS_START __bss_start__
#elif defined( _MSC_VER ) || defined( __MINGW32__ )
#define BSS_START *bss_start
#define _end *bss_end
#else
#define BSS_START __bss_start
#endif
@ -141,7 +144,8 @@ void gc_collect(void) {
regs_t regs;
gc_helper_get_regs(regs);
// GC stack (and regs because we captured them)
gc_collect_root((void**)&regs, ((machine_uint_t)stack_top - (machine_uint_t)&regs) / sizeof(machine_uint_t));
void **regs_ptr = (void**)(void*)&regs;
gc_collect_root(regs_ptr, ((machine_uint_t)stack_top - (machine_uint_t)&regs) / sizeof(machine_uint_t));
gc_collect_end();
//printf("-----\n");

9
unix/main.c
View File

@ -201,8 +201,8 @@ int usage(char **argv) {
impl_opts_cnt++;
#if MICROPY_ENABLE_GC
printf(
" heapsize=<n> -- set the heap size for the GC\n"
);
" heapsize=<n> -- set the heap size for the GC (default %ld)\n"
, heap_size);
impl_opts_cnt++;
#endif
@ -365,7 +365,8 @@ int main(int argc, char **argv) {
return usage(argv);
}
} else {
char *basedir = realpath(argv[a], NULL);
char *pathbuf = malloc(PATH_MAX);
char *basedir = realpath(argv[a], pathbuf);
if (basedir == NULL) {
fprintf(stderr, "%s: can't open file '%s': [Errno %d] ", argv[0], argv[a], errno);
perror("");
@ -377,7 +378,7 @@ int main(int argc, char **argv) {
// Set base dir of the script as first entry in sys.path
char *p = strrchr(basedir, '/');
path_items[0] = MP_OBJ_NEW_QSTR(qstr_from_strn(basedir, p - basedir));
free(basedir);
free(pathbuf);
for (int i = a; i < argc; i++) {
mp_obj_list_append(mp_sys_argv, MP_OBJ_NEW_QSTR(qstr_from_str(argv[i])));

4
unix/modffi.c
View File

@ -421,8 +421,8 @@ STATIC const mp_obj_dict_t mp_module_ffi_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_ffi_globals_table),
.alloc = ARRAY_SIZE(mp_module_ffi_globals_table),
.used = MP_ARRAY_SIZE(mp_module_ffi_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_ffi_globals_table),
.table = (mp_map_elem_t*)mp_module_ffi_globals_table,
},
};

4
unix/modos.c
View File

@ -75,8 +75,8 @@ STATIC const mp_obj_dict_t mp_module_os_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_os_globals_table),
.alloc = ARRAY_SIZE(mp_module_os_globals_table),
.used = MP_ARRAY_SIZE(mp_module_os_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_os_globals_table),
.table = (mp_map_elem_t*)mp_module_os_globals_table,
},
};

31
unix/modsocket.c
View File

@ -356,6 +356,8 @@ STATIC mp_obj_t mod_socket_getaddrinfo(uint n_args, const mp_obj_t *args) {
const char *host = mp_obj_str_get_str(args[0]);
const char *serv = NULL;
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
// getaddrinfo accepts port in string notation, so however
// it may seem stupid, we need to convert int to str
if (MP_OBJ_IS_SMALL_INT(args[1])) {
@ -363,23 +365,35 @@ STATIC mp_obj_t mod_socket_getaddrinfo(uint n_args, const mp_obj_t *args) {
char buf[6];
sprintf(buf, "%d", port);
serv = buf;
hints.ai_flags = AI_NUMERICSERV;
#ifdef __UCLIBC_MAJOR__
#if __UCLIBC_MAJOR__ == 0 && (__UCLIBC_MINOR__ < 9 || (__UCLIBC_MINOR__ == 9 && __UCLIBC_SUBLEVEL__ <= 32))
#warning Working around uClibc bug with numeric service name
// Older versions og uClibc have bugs when numeric ports in service
// arg require also hints.ai_socktype (or hints.ai_protocol) != 0
// This actually was fixed in 0.9.32.1, but uClibc doesn't allow to
// test for that.
// http://git.uclibc.org/uClibc/commit/libc/inet/getaddrinfo.c?id=bc3be18145e4d5
// Note that this is crude workaround, precluding UDP socket addresses
// to be returned. TODO: set only if not set by Python args.
hints.ai_socktype = SOCK_STREAM;
#endif
#endif
} else {
serv = mp_obj_str_get_str(args[1]);
}
struct addrinfo hints;
struct addrinfo *addr;
memset(&hints, 0, sizeof(hints));
int res = getaddrinfo(host, serv, NULL/*&hints*/, &addr);
struct addrinfo *addr_list;
int res = getaddrinfo(host, serv, &hints, &addr_list);
if (res != 0) {
// CPython: socket.gaierror
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "[addrinfo error %d]", res));
}
assert(addr);
assert(addr_list);
mp_obj_t list = mp_obj_new_list(0, NULL);
for (; addr; addr = addr->ai_next) {
for (struct addrinfo *addr = addr_list; addr; addr = addr->ai_next) {
mp_obj_tuple_t *t = mp_obj_new_tuple(5, NULL);
t->items[0] = MP_OBJ_NEW_SMALL_INT((machine_int_t)addr->ai_family);
t->items[1] = MP_OBJ_NEW_SMALL_INT((machine_int_t)addr->ai_socktype);
@ -394,6 +408,7 @@ STATIC mp_obj_t mod_socket_getaddrinfo(uint n_args, const mp_obj_t *args) {
t->items[4] = mp_obj_new_bytearray(addr->ai_addrlen, addr->ai_addr);
mp_obj_list_append(list, t);
}
freeaddrinfo(addr_list);
return list;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_socket_getaddrinfo_obj, 2, 6, mod_socket_getaddrinfo);
@ -436,8 +451,8 @@ STATIC const mp_obj_dict_t mp_module_socket_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_socket_globals_table),
.alloc = ARRAY_SIZE(mp_module_socket_globals_table),
.used = MP_ARRAY_SIZE(mp_module_socket_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_socket_globals_table),
.table = (mp_map_elem_t*)mp_module_socket_globals_table,
},
};

4
unix/modtime.c
View File

@ -113,8 +113,8 @@ STATIC const mp_obj_dict_t mp_module_time_globals = {
.map = {
.all_keys_are_qstrs = 1,
.table_is_fixed_array = 1,
.used = ARRAY_SIZE(mp_module_time_globals_table),
.alloc = ARRAY_SIZE(mp_module_time_globals_table),
.used = MP_ARRAY_SIZE(mp_module_time_globals_table),
.alloc = MP_ARRAY_SIZE(mp_module_time_globals_table),
.table = (mp_map_elem_t*)mp_module_time_globals_table,
},
};

2
unix/mpconfigport.h
View File

@ -53,7 +53,9 @@
#define MICROPY_ERROR_REPORTING (MICROPY_ERROR_REPORTING_DETAILED)
// Define to 1 to use untested inefficient GC helper implementation
// (if more efficient arch-specific one is not available).
#ifndef MICROPY_GCREGS_SETJMP
#define MICROPY_GCREGS_SETJMP (0)
#endif
extern const struct _mp_obj_module_t mp_module_os;
extern const struct _mp_obj_module_t mp_module_time;

2
windows/Makefile
View File

@ -35,9 +35,11 @@ SRC_C = \
unix/file.c \
unix/input.c \
unix/modtime.c \
unix/gccollect.c \
realpath.c \
init.c \
sleep.c \
bss.c \
OBJ = $(PY_O) $(addprefix $(BUILD)/, $(SRC_C:.c=.o))

74
windows/bss.c 100644
View File

@ -0,0 +1,74 @@
/*
* This file is part of the Micro Python 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.
*/
#include "mpconfig.h"
#include "misc.h"
#include "nlr.h"
#include "qstr.h"
#include "obj.h"
#include <windows.h>
IMAGE_NT_HEADERS *header_from_memory(const char *module) {
BYTE *base_addr = (BYTE*)GetModuleHandleA(module);
IMAGE_DOS_HEADER *dos_header = (IMAGE_DOS_HEADER*)base_addr;
return (IMAGE_NT_HEADERS*)(base_addr + dos_header->e_lfanew);
}
IMAGE_SECTION_HEADER *find_section(IMAGE_NT_HEADERS *nt_header, const char *name) {
int i;
IMAGE_SECTION_HEADER *section = IMAGE_FIRST_SECTION(nt_header);
for (i = 0; i < nt_header->FileHeader.NumberOfSections; ++i) {
if (strcmp((const char *)section->Name, name) == 0) {
return section;
}
++section;
}
return NULL;
}
void section_boundaries(IMAGE_NT_HEADERS *nt_header, IMAGE_SECTION_HEADER *section, char **start, char **end) {
if (section == NULL) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "Could not lookup section boundaries"));
}
*start = (char*)(nt_header->OptionalHeader.ImageBase + section->VirtualAddress);
*end = *start + section->Misc.VirtualSize;
}
void section_boundaries_from_module(const char *module, const char *section, char **start, char **end) {
IMAGE_NT_HEADERS *nt_header = header_from_memory(module);
IMAGE_SECTION_HEADER *dsection = find_section(nt_header, section);
section_boundaries(nt_header, dsection, start, end);
}
char *bss_start = 0;
char *bss_end = 0;
//MSVC has no __bss_start and _end but we can get accurate section info from the PE header.
//The standard .bss section is appended to the standard .data section however so it cannot
//be looked up by name. To deal with that we put all uPy static variables in a named section.
void getbss() {
section_boundaries_from_module(NULL, MICROPY_PORT_BSSSECTION, &bss_start, &bss_end);
}

3
windows/init.c
View File

@ -28,9 +28,12 @@
#include <stdio.h>
#include <windows.h>
extern void getbss();
HANDLE hSleepEvent = NULL;
void init() {
getbss();
hSleepEvent = CreateEvent(NULL, TRUE, FALSE, FALSE);
#ifdef __MINGW32__
putenv("PRINTF_EXPONENT_DIGITS=2");

19
windows/mpconfigport.h
View File

@ -43,6 +43,12 @@
#define MICROPY_PY_CMATH (1)
#define MICROPY_PY_SYS_STDFILES (1)
#define MICROPY_PY_SYS_EXIT (1)
#define MICROPY_ENABLE_GC (1)
#define MICROPY_ENABLE_FINALISER (1)
#define MICROPY_PY_GC_COLLECT_RETVAL (1)
#ifdef _MSC_VER
#define MICROPY_GCREGS_SETJMP (1)
#endif
#define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_DOUBLE)
#define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_MPZ)
#define MICROPY_PORT_INIT_FUNC init()
@ -113,6 +119,14 @@ void msec_sleep(double msec);
#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
// Put static/global variables in sections with a known name we can lookup for the GC
// For this to work this header must be included by all sources, which is the case normally
#define MICROPY_PORT_DATASECTION "upydata"
#define MICROPY_PORT_BSSSECTION "upybss"
#pragma data_seg(MICROPY_PORT_DATASECTION)
#pragma bss_seg(MICROPY_PORT_BSSSECTION)
// System headers (needed e.g. for nlr.h)
#include <stddef.h> //for NULL
@ -122,3 +136,8 @@ void msec_sleep(double msec);
int snprintf(char *dest, size_t count, const char *format, ...);
#endif
// MingW specifics
#ifdef __MINGW32__
#define MICROPY_PORT_BSSSECTION ".bss"
#endif

3
windows/msvc/common.props
View File

@ -16,7 +16,8 @@
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
<GenerateMapFile>true</GenerateMapFile>
</Link>
</ItemDefinitionGroup>
<ItemGroup />
</Project>
</Project>

2
windows/msvc/sources.props
View File

@ -5,7 +5,7 @@
</PropertyGroup>
<ItemGroup>
<ClCompile Include="$(PyBaseDir)py\*.c" />
<ClCompile Include="$(PyBaseDir)unix\*.c" Exclude="$(PyBaseDir)unix\modffi.c;$(PyBaseDir)unix\modsocket.c" />
<ClCompile Include="$(PyBaseDir)unix\*.c" Exclude="$(PyBaseDir)unix\modffi.c;$(PyBaseDir)unix\modsocket.c;$(PyBaseDir)unix\seg_helpers.c" />
<ClCompile Include="$(PyBaseDir)windows\*.c" />
<ClCompile Include="$(PyBaseDir)windows\msvc\*.c" />
</ItemGroup>