Merge remote-tracking branch 'upstream/master' into listsort. Lots of conflict fun.
Conflicts: py/obj.h py/objbool.c py/objboundmeth.c py/objcell.c py/objclass.c py/objclosure.c py/objcomplex.c py/objdict.c py/objexcept.c py/objfun.c py/objgenerator.c py/objinstance.c py/objmodule.c py/objrange.c py/objset.c py/objslice.c
This commit is contained in:
John R. Lenton
commit
270112f731
|
|
@ -0,0 +1,14 @@
|
|||
# log the accelerometer values to a file, 1 per second
|
||||
|
||||
f = open('motion.dat', 'w') # open the file for writing
|
||||
|
||||
for i in range(60): # loop 60 times
|
||||
time = pyb.time() # get the current time
|
||||
accel = pyb.accel() # get the accelerometer data
|
||||
|
||||
# write time and x,y,z values to the file
|
||||
f.write('{} {} {} {}\n'.format(time, accel[0], accel[1], accel[2]))
|
||||
|
||||
pyb.delay(1000) # wait 1000 ms = 1 second
|
||||
|
||||
f.close() # close the file
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
# do 1 iteration of Conway's Game of Life
|
||||
def conway_step():
|
||||
for x in range(128): # loop over x coordinates
|
||||
for y in range(32): # loop over y coordinates
|
||||
# count number of neigbours
|
||||
num_neighbours = (lcd.get(x - 1, y - 1) +
|
||||
lcd.get(x, y - 1) +
|
||||
lcd.get(x + 1, y - 1) +
|
||||
lcd.get(x - 1, y) +
|
||||
lcd.get(x + 1, y) +
|
||||
lcd.get(x + 1, y + 1) +
|
||||
lcd.get(x, y + 1) +
|
||||
lcd.get(x - 1, y + 1))
|
||||
|
||||
# check if the centre cell is alive or not
|
||||
self = lcd.get(x, y)
|
||||
|
||||
# apply the rules of life
|
||||
if self and not (2 <= num_neighbours <= 3):
|
||||
lcd.reset(x, y) # not enough, or too many neighbours: cell dies
|
||||
elif not self and num_neighbours == 3:
|
||||
lcd.set(x, y) # exactly 3 neigbours around an empty cell: cell is born
|
||||
|
||||
# randomise the start
|
||||
def conway_rand():
|
||||
lcd.clear() # clear the LCD
|
||||
for x in range(128): # loop over x coordinates
|
||||
for y in range(32): # loop over y coordinates
|
||||
if pyb.rand() & 1: # get a 1-bit random number
|
||||
lcd.set(x, y) # set the pixel randomly
|
||||
|
||||
# loop for a certain number of frames, doing iterations of Conway's Game of Life
|
||||
def conway_go(num_frames):
|
||||
for i in range(num_frames):
|
||||
conway_step() # do 1 iteration
|
||||
lcd.show() # update the LCD
|
||||
|
||||
# PC testing
|
||||
import lcd
|
||||
import pyb
|
||||
lcd = lcd.LCD(128, 32)
|
||||
conway_rand()
|
||||
conway_go(100)
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
# LCD testing object for PC
|
||||
# uses double buffering
|
||||
class LCD:
|
||||
def __init__(self, width, height):
|
||||
self.width = width
|
||||
self.height = height
|
||||
self.buf1 = [[0 for x in range(self.width)] for y in range(self.height)]
|
||||
self.buf2 = [[0 for x in range(self.width)] for y in range(self.height)]
|
||||
|
||||
def clear(self):
|
||||
for y in range(self.height):
|
||||
for x in range(self.width):
|
||||
self.buf1[y][x] = self.buf2[y][x] = 0
|
||||
|
||||
def show(self):
|
||||
print('') # blank line to separate frames
|
||||
for y in range(self.height):
|
||||
for x in range(self.width):
|
||||
self.buf1[y][x] = self.buf2[y][x]
|
||||
for y in range(self.height):
|
||||
row = ''.join(['*' if self.buf1[y][x] else ' ' for x in range(self.width)])
|
||||
print(row)
|
||||
|
||||
def get(self, x, y):
|
||||
if 0 <= x < self.width and 0 <= y < self.height:
|
||||
return self.buf1[y][x]
|
||||
else:
|
||||
return 0
|
||||
|
||||
def reset(self, x, y):
|
||||
if 0 <= x < self.width and 0 <= y < self.height:
|
||||
self.buf2[y][x] = 0
|
||||
|
||||
def set(self, x, y):
|
||||
if 0 <= x < self.width and 0 <= y < self.height:
|
||||
self.buf2[y][x] = 1
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
def led_angle(seconds_to_run_for):
|
||||
# make LED objects
|
||||
l1 = pyb.Led(1)
|
||||
l2 = pyb.Led(2)
|
||||
|
||||
for i in range(20 * seconds_to_run_for):
|
||||
# get x-axis
|
||||
accel = pyb.accel()[0]
|
||||
|
||||
# turn on LEDs depending on angle
|
||||
if accel < -10:
|
||||
l1.on()
|
||||
l2.off()
|
||||
elif accel > 10:
|
||||
l1.off()
|
||||
l2.on()
|
||||
else:
|
||||
l1.off()
|
||||
l2.off()
|
||||
|
||||
# delay so that loop runs at at 1/50ms = 20Hz
|
||||
pyb.delay(50)
|
||||
|
|
@ -1,14 +1,22 @@
|
|||
@micropython.native
|
||||
def in_set(c):
|
||||
z = 0
|
||||
for i in range(40):
|
||||
z = z*z + c
|
||||
if abs(z) > 60:
|
||||
return False
|
||||
return True
|
||||
def mandelbrot():
|
||||
# returns True if c, complex, is in the Mandelbrot set
|
||||
@micropython.native
|
||||
def in_set(c):
|
||||
z = 0
|
||||
for i in range(40):
|
||||
z = z*z + c
|
||||
if abs(z) > 60:
|
||||
return False
|
||||
return True
|
||||
|
||||
for v in range(31):
|
||||
line = []
|
||||
lcd.clear()
|
||||
for u in range(91):
|
||||
line.append('*' if in_set((u / 30 - 2) + (v / 15 - 1) * 1j) else ' ')
|
||||
print(''.join(line))
|
||||
for v in range(31):
|
||||
if in_set((u / 30 - 2) + (v / 15 - 1) * 1j):
|
||||
lcd.set(u, v)
|
||||
lcd.show()
|
||||
|
||||
# PC testing
|
||||
import lcd
|
||||
lcd = lcd.LCD(128, 32)
|
||||
mandelbrot()
|
||||
|
|
|
|||
|
|
@ -0,0 +1,11 @@
|
|||
# pyboard testing functions for PC
|
||||
|
||||
def delay(n):
|
||||
pass
|
||||
|
||||
rand_seed = 1
|
||||
def rand():
|
||||
global rand_seed
|
||||
# for these choice of numbers, see P L'Ecuyer, "Tables of linear congruential generators of different sizes and good lattice structure"
|
||||
rand_seed = (rand_seed * 653276) % 8388593
|
||||
return rand_seed
|
||||
File diff suppressed because one or more lines are too long
|
After Width: | Height: | Size: 36 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 89 KiB |
File diff suppressed because one or more lines are too long
|
After Width: | Height: | Size: 115 KiB |
|
|
@ -1,16 +1,18 @@
|
|||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/mman.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "misc.h"
|
||||
#include "asmx64.h"
|
||||
#include "mpconfig.h"
|
||||
|
||||
// wrapper around everything in this file
|
||||
#if MICROPY_EMIT_X64
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/mman.h>
|
||||
|
||||
#include "asmx64.h"
|
||||
|
||||
#if defined(__OpenBSD__) || defined(__MACH__)
|
||||
#define MAP_ANONYMOUS MAP_ANON
|
||||
#endif
|
||||
|
|
|
|||
4
py/gc.c
4
py/gc.c
|
|
@ -6,6 +6,8 @@
|
|||
#include "mpconfig.h"
|
||||
#include "gc.h"
|
||||
|
||||
#if MICROPY_ENABLE_GC
|
||||
|
||||
// a machine word is big enough to hold a pointer
|
||||
/*
|
||||
#define BYTES_PER_WORD (8)
|
||||
|
|
@ -380,3 +382,5 @@ int main(void) {
|
|||
gc_dump_at();
|
||||
}
|
||||
*/
|
||||
|
||||
#endif // MICROPY_ENABLE_GC
|
||||
|
|
|
|||
|
|
@ -4,8 +4,11 @@
|
|||
#include <fcntl.h>
|
||||
|
||||
#include "misc.h"
|
||||
#include "mpconfig.h"
|
||||
#include "lexer.h"
|
||||
|
||||
#if MICROPY_ENABLE_LEXER_UNIX
|
||||
|
||||
typedef struct _str_buf_t {
|
||||
bool free; // free src_beg when done
|
||||
const char *src_beg; // beginning of source
|
||||
|
|
@ -78,3 +81,5 @@ mp_lexer_t *mp_import_open_file(qstr mod_name) {
|
|||
vstr_printf(vstr, "%s.py", qstr_str(mod_name));
|
||||
return mp_lexer_new_from_file(vstr_str(vstr)); // TODO does lexer need to copy the string? can we free it here?
|
||||
}
|
||||
|
||||
#endif // MICROPY_ENABLE_LEXER_UNIX
|
||||
|
|
|
|||
|
|
@ -5,11 +5,7 @@
|
|||
|
||||
/** types *******************************************************/
|
||||
|
||||
typedef int bool;
|
||||
enum {
|
||||
false = 0,
|
||||
true = 1
|
||||
};
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef unsigned char byte;
|
||||
typedef unsigned int uint;
|
||||
|
|
|
|||
|
|
@ -4,8 +4,80 @@
|
|||
|
||||
#include <mpconfigport.h>
|
||||
|
||||
#ifndef INT_FMT
|
||||
// Any options not explicitly set in mpconfigport.h will get default
|
||||
// values below.
|
||||
|
||||
/*****************************************************************************/
|
||||
/* Micro Python emitters */
|
||||
|
||||
// Whether to emit CPython byte codes (for debugging/testing)
|
||||
// Enabling this overrides all other emitters
|
||||
#ifndef MICROPY_EMIT_CPYTHON
|
||||
#define MICROPY_EMIT_CPYTHON (0)
|
||||
#endif
|
||||
|
||||
// Whether to emit x64 native code
|
||||
#ifndef MICROPY_EMIT_X64
|
||||
#define MICROPY_EMIT_X64 (0)
|
||||
#endif
|
||||
|
||||
// Whether to emit thumb native code
|
||||
#ifndef MICROPY_EMIT_THUMB
|
||||
#define MICROPY_EMIT_THUMB (0)
|
||||
#endif
|
||||
|
||||
// Whether to enable the thumb inline assembler
|
||||
#ifndef MICROPY_EMIT_INLINE_THUMB
|
||||
#define MICROPY_EMIT_INLINE_THUMB (0)
|
||||
#endif
|
||||
|
||||
/*****************************************************************************/
|
||||
/* Internal debugging stuff */
|
||||
|
||||
// Whether to collect memory allocation stats
|
||||
#ifndef MICROPY_MEM_STATS
|
||||
#define MICROPY_MEM_STATS (0)
|
||||
#endif
|
||||
|
||||
// Whether to build code to show byte code
|
||||
#ifndef MICROPY_SHOW_BC
|
||||
#define MICROPY_SHOW_BC (0)
|
||||
#endif
|
||||
|
||||
/*****************************************************************************/
|
||||
/* Fine control over Python features */
|
||||
|
||||
// Whether to include the garbage collector
|
||||
#ifndef MICROPY_ENABLE_GC
|
||||
#define MICROPY_ENABLE_GC (0)
|
||||
#endif
|
||||
|
||||
// Whether to include REPL helper function
|
||||
#ifndef MICROPY_ENABLE_REPL_HELPERS
|
||||
#define MICROPY_ENABLE_REPL_HELPERS (0)
|
||||
#endif
|
||||
|
||||
// Whether to include lexer helper function for unix
|
||||
#ifndef MICROPY_ENABLE_LEXER_UNIX
|
||||
#define MICROPY_ENABLE_LEXER_UNIX (0)
|
||||
#endif
|
||||
|
||||
// Whether to support float and complex types
|
||||
#ifndef MICROPY_ENABLE_FLOAT
|
||||
#define MICROPY_ENABLE_FLOAT (0)
|
||||
#endif
|
||||
|
||||
// Whether to support slice object and correspondingly
|
||||
// slice subscript operators
|
||||
#ifndef MICROPY_ENABLE_SLICE
|
||||
#define MICROPY_ENABLE_SLICE (1)
|
||||
#endif
|
||||
|
||||
/*****************************************************************************/
|
||||
/* Miscellaneous settings */
|
||||
|
||||
// printf format spec to use for machine_int_t and friends
|
||||
#ifndef INT_FMT
|
||||
#ifdef __LP64__
|
||||
// Archs where machine_int_t == long, long != int
|
||||
#define UINT_FMT "%lu"
|
||||
|
|
@ -16,18 +88,3 @@
|
|||
#define INT_FMT "%d"
|
||||
#endif
|
||||
#endif //INT_FMT
|
||||
|
||||
|
||||
// Any options not explicitly set in mpconfigport.h will get default
|
||||
// values below.
|
||||
|
||||
// Whether to collect memory allocation stats
|
||||
#ifndef MICROPY_MEM_STATS
|
||||
#define MICROPY_MEM_STATS (1)
|
||||
#endif
|
||||
|
||||
// Whether to support slice object and correspondingly
|
||||
// slice subscript operators
|
||||
#ifndef MICROPY_ENABLE_SLICE
|
||||
#define MICROPY_ENABLE_SLICE (1)
|
||||
#endif
|
||||
|
|
|
|||
31
py/obj.h
31
py/obj.h
|
|
@ -15,15 +15,14 @@ typedef machine_int_t mp_small_int_t;
|
|||
typedef machine_float_t mp_float_t;
|
||||
#endif
|
||||
|
||||
// Anything that wants to be a Micro Python object must
|
||||
// have mp_obj_base_t as its first member (except NULL and small ints)
|
||||
|
||||
typedef struct _mp_obj_base_t mp_obj_base_t;
|
||||
typedef struct _mp_obj_type_t mp_obj_type_t;
|
||||
// Anything that wants to be a Micro Python object must have
|
||||
// mp_obj_base_t as its first member (except NULL and small ints)
|
||||
|
||||
struct _mp_obj_type_t;
|
||||
struct _mp_obj_base_t {
|
||||
const mp_obj_type_t *type;
|
||||
const struct _mp_obj_type_t *type;
|
||||
};
|
||||
typedef struct _mp_obj_base_t mp_obj_base_t;
|
||||
|
||||
// The NULL object is used to indicate the absence of an object
|
||||
// It *cannot* be used when an mp_obj_t is expected, except where explicitly allowed
|
||||
|
|
@ -43,13 +42,14 @@ struct _mp_obj_base_t {
|
|||
|
||||
#define MP_DECLARE_CONST_FUN_OBJ(obj_name) extern const mp_obj_fun_native_t obj_name
|
||||
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_0(obj_name, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, false, 0, 0, fun_name}
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_1(obj_name, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, false, 1, 1, fun_name}
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_2(obj_name, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, false, 2, 2, fun_name}
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_3(obj_name, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, false, 3, 3, fun_name}
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_VAR(obj_name, n_args_min, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, false, n_args_min, (~((machine_uint_t)0)), fun_name}
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(obj_name, n_args_min, n_args_max, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, false, n_args_min, n_args_max, fun_name}
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_KW(obj_name, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, true, 0, (~((machine_uint_t)0)), fun_name}
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, is_kw, n_args_min, n_args_max, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, is_kw, n_args_min, n_args_max, (void *)fun_name}
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_0(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 0, 0, (mp_fun_0_t)fun_name)
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_1(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 1, 1, (mp_fun_1_t)fun_name)
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_2(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 2, 2, (mp_fun_2_t)fun_name)
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_3(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 3, 3, (mp_fun_3_t)fun_name)
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_VAR(obj_name, n_args_min, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, n_args_min, (~((machine_uint_t)0)), (mp_fun_var_t)fun_name)
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(obj_name, n_args_min, n_args_max, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, n_args_min, n_args_max, (mp_fun_var_t)fun_name)
|
||||
#define MP_DEFINE_CONST_FUN_OBJ_KW(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, true, 0, (~((machine_uint_t)0)), (mp_fun_var_t)fun_name)
|
||||
|
||||
// Need to declare this here so we are not dependent on map.h
|
||||
struct _mp_map_t;
|
||||
|
|
@ -90,7 +90,7 @@ struct _mp_obj_type_t {
|
|||
mp_fun_1_t getiter;
|
||||
mp_fun_1_t iternext;
|
||||
|
||||
const mp_method_t methods[];
|
||||
const mp_method_t *methods;
|
||||
|
||||
/*
|
||||
What we might need to add here:
|
||||
|
|
@ -115,6 +115,8 @@ struct _mp_obj_type_t {
|
|||
*/
|
||||
};
|
||||
|
||||
typedef struct _mp_obj_type_t mp_obj_type_t;
|
||||
|
||||
// Constant objects, globally accessible
|
||||
|
||||
extern const mp_obj_type_t mp_const_type;
|
||||
|
|
@ -245,6 +247,7 @@ typedef struct _mp_obj_fun_native_t { // need this so we can define const object
|
|||
// for const function objects, make an empty, const map
|
||||
// such functions won't be able to access the global scope, but that's probably okay
|
||||
} mp_obj_fun_native_t;
|
||||
|
||||
extern const mp_obj_type_t fun_native_type;
|
||||
extern const mp_obj_type_t fun_bc_type;
|
||||
void mp_obj_fun_bc_get(mp_obj_t self_in, int *n_args, uint *n_state, const byte **code);
|
||||
|
|
|
|||
|
|
@ -32,11 +32,10 @@ static mp_obj_t bool_make_new(mp_obj_t type_in, int n_args, const mp_obj_t *args
|
|||
}
|
||||
|
||||
const mp_obj_type_t bool_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "bool",
|
||||
{ &mp_const_type },
|
||||
"bool",
|
||||
.print = bool_print,
|
||||
.make_new = bool_make_new,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
static const mp_obj_bool_t false_obj = {{&bool_type}, false};
|
||||
|
|
|
|||
|
|
@ -34,10 +34,9 @@ mp_obj_t bound_meth_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
|
|||
}
|
||||
|
||||
const mp_obj_type_t bound_meth_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "bound_method",
|
||||
{ &mp_const_type },
|
||||
"bound_method",
|
||||
.call_n = bound_meth_call_n,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_bound_meth(mp_obj_t self, mp_obj_t meth) {
|
||||
|
|
|
|||
|
|
@ -24,9 +24,8 @@ void mp_obj_cell_set(mp_obj_t self_in, mp_obj_t obj) {
|
|||
}
|
||||
|
||||
const mp_obj_type_t cell_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "cell",
|
||||
.methods = {{NULL, NULL},},
|
||||
{ &mp_const_type },
|
||||
"cell",
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_cell(mp_obj_t obj) {
|
||||
|
|
|
|||
|
|
@ -61,10 +61,9 @@ mp_map_t *mp_obj_class_get_locals(mp_obj_t self_in) {
|
|||
}
|
||||
|
||||
const mp_obj_type_t class_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "class",
|
||||
{ &mp_const_type },
|
||||
"class",
|
||||
.call_n = class_call_n,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_class(mp_map_t *class_locals) {
|
||||
|
|
|
|||
|
|
@ -33,10 +33,9 @@ mp_obj_t closure_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
|
|||
}
|
||||
|
||||
const mp_obj_type_t closure_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "closure",
|
||||
{ &mp_const_type },
|
||||
"closure",
|
||||
.call_n = closure_call_n,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_closure(mp_obj_t fun, mp_obj_t closure_tuple) {
|
||||
|
|
|
|||
|
|
@ -85,13 +85,12 @@ static mp_obj_t complex_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
|
|||
}
|
||||
|
||||
const mp_obj_type_t complex_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "complex",
|
||||
{ &mp_const_type },
|
||||
"complex",
|
||||
.print = complex_print,
|
||||
.make_new = complex_make_new,
|
||||
.unary_op = complex_unary_op,
|
||||
.binary_op = complex_binary_op,
|
||||
.methods = { { NULL, NULL }, },
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_complex(mp_float_t real, mp_float_t imag) {
|
||||
|
|
|
|||
|
|
@ -66,7 +66,6 @@ const mp_obj_type_t dict_type = {
|
|||
.print = dict_print,
|
||||
.make_new = dict_make_new,
|
||||
.binary_op = dict_binary_op,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_dict(int n_args) {
|
||||
|
|
|
|||
|
|
@ -36,10 +36,9 @@ void exception_print(void (*print)(void *env, const char *fmt, ...), void *env,
|
|||
}
|
||||
|
||||
const mp_obj_type_t exception_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "exception",
|
||||
{ &mp_const_type },
|
||||
"exception",
|
||||
.print = exception_print,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_exception(qstr id) {
|
||||
|
|
|
|||
|
|
@ -68,7 +68,6 @@ const mp_obj_type_t float_type = {
|
|||
.make_new = float_make_new,
|
||||
.unary_op = float_unary_op,
|
||||
.binary_op = float_binary_op,
|
||||
.methods = { { NULL, NULL }, },
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_float(mp_float_t value) {
|
||||
|
|
|
|||
21
py/objfun.c
21
py/objfun.c
|
|
@ -92,13 +92,10 @@ mp_obj_t fun_native_call_n_kw(mp_obj_t self_in, int n_args, int n_kw, const mp_o
|
|||
}
|
||||
|
||||
const mp_obj_type_t fun_native_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "function",
|
||||
{ &mp_const_type },
|
||||
"function",
|
||||
.call_n = fun_native_call_n,
|
||||
.call_n_kw = fun_native_call_n_kw,
|
||||
.methods = {
|
||||
{NULL, NULL}, // end-of-list sentinel
|
||||
},
|
||||
};
|
||||
|
||||
mp_obj_t rt_make_function_0(mp_fun_0_t fun) {
|
||||
|
|
@ -189,12 +186,9 @@ mp_obj_t fun_bc_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
|
|||
}
|
||||
|
||||
const mp_obj_type_t fun_bc_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "function",
|
||||
{ &mp_const_type },
|
||||
"function",
|
||||
.call_n = fun_bc_call_n,
|
||||
.methods = {
|
||||
{NULL, NULL}, // end-of-list sentinel
|
||||
},
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_fun_bc(int n_args, uint n_state, const byte *code) {
|
||||
|
|
@ -297,12 +291,9 @@ mp_obj_t fun_asm_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
|
|||
}
|
||||
|
||||
static const mp_obj_type_t fun_asm_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "function",
|
||||
{ &mp_const_type },
|
||||
"function",
|
||||
.call_n = fun_asm_call_n,
|
||||
.methods = {
|
||||
{NULL, NULL}, // end-of-list sentinel
|
||||
},
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_fun_asm(uint n_args, void *fun) {
|
||||
|
|
|
|||
|
|
@ -37,12 +37,9 @@ mp_obj_t gen_wrap_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
|
|||
}
|
||||
|
||||
const mp_obj_type_t gen_wrap_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "generator",
|
||||
{ &mp_const_type },
|
||||
"generator",
|
||||
.call_n = gen_wrap_call_n,
|
||||
.unary_op = NULL,
|
||||
.binary_op = NULL,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_gen_wrap(uint n_locals, uint n_stack, mp_obj_t fun) {
|
||||
|
|
@ -88,12 +85,11 @@ mp_obj_t gen_instance_iternext(mp_obj_t self_in) {
|
|||
}
|
||||
|
||||
const mp_obj_type_t gen_instance_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "generator",
|
||||
{ &mp_const_type },
|
||||
"generator",
|
||||
.print = gen_instance_print,
|
||||
.getiter = gen_instance_getiter,
|
||||
.iternext = gen_instance_iternext,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
// args are in reverse order in the array
|
||||
|
|
|
|||
|
|
@ -90,9 +90,8 @@ void mp_obj_instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
|
|||
}
|
||||
|
||||
const mp_obj_type_t instance_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "instance",
|
||||
.methods = {{NULL, NULL},},
|
||||
{ &mp_const_type },
|
||||
"instance",
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_instance(mp_obj_t class) {
|
||||
|
|
|
|||
|
|
@ -34,7 +34,6 @@ const mp_obj_type_t int_type = {
|
|||
.base = { &mp_const_type },
|
||||
.name = "int",
|
||||
.make_new = int_make_new,
|
||||
.methods = { { NULL, NULL }, },
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_int(machine_int_t value) {
|
||||
|
|
|
|||
31
py/objlist.c
31
py/objlist.c
|
|
@ -58,6 +58,7 @@ static mp_obj_t list_make_new(mp_obj_t type_in, int n_args, const mp_obj_t *args
|
|||
default:
|
||||
nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "list takes at most 1 argument, %d given", (void*)(machine_int_t)n_args));
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static mp_obj_t list_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
|
||||
|
|
@ -277,27 +278,28 @@ static MP_DEFINE_CONST_FUN_OBJ_2(list_remove_obj, list_remove);
|
|||
static MP_DEFINE_CONST_FUN_OBJ_1(list_reverse_obj, list_reverse);
|
||||
static MP_DEFINE_CONST_FUN_OBJ_KW(list_sort_obj, list_sort);
|
||||
|
||||
static const mp_method_t list_type_methods[] = {
|
||||
{ "append", &list_append_obj },
|
||||
{ "clear", &list_clear_obj },
|
||||
{ "copy", &list_copy_obj },
|
||||
{ "count", &list_count_obj },
|
||||
{ "index", &list_index_obj },
|
||||
{ "insert", &list_insert_obj },
|
||||
{ "pop", &list_pop_obj },
|
||||
{ "remove", &list_remove_obj },
|
||||
{ "reverse", &list_reverse_obj },
|
||||
{ "sort", &list_sort_obj },
|
||||
{ NULL, NULL }, // end-of-list sentinel
|
||||
};
|
||||
|
||||
const mp_obj_type_t list_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "list",
|
||||
.print = list_print,
|
||||
.make_new = list_make_new,
|
||||
.unary_op = NULL,
|
||||
.binary_op = list_binary_op,
|
||||
.getiter = list_getiter,
|
||||
.methods = {
|
||||
{ "append", &list_append_obj },
|
||||
{ "clear", &list_clear_obj },
|
||||
{ "copy", &list_copy_obj },
|
||||
{ "count", &list_count_obj },
|
||||
{ "index", &list_index_obj },
|
||||
{ "insert", &list_insert_obj },
|
||||
{ "pop", &list_pop_obj },
|
||||
{ "remove", &list_remove_obj },
|
||||
{ "reverse", &list_reverse_obj },
|
||||
{ "sort", &list_sort_obj },
|
||||
{ NULL, NULL }, // end-of-list sentinel
|
||||
},
|
||||
.methods = list_type_methods,
|
||||
};
|
||||
|
||||
static mp_obj_list_t *list_new(uint n) {
|
||||
|
|
@ -361,7 +363,6 @@ static const mp_obj_type_t list_it_type = {
|
|||
.base = { &mp_const_type },
|
||||
.name = "list_iterator",
|
||||
.iternext = list_it_iternext,
|
||||
.methods = { { NULL, NULL }, },
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_list_iterator(mp_obj_list_t *list, int cur) {
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
#include "nlr.h"
|
||||
#include "misc.h"
|
||||
#include "mpconfig.h"
|
||||
#include "mpqstr.h"
|
||||
#include "obj.h"
|
||||
#include "runtime.h"
|
||||
#include "map.h"
|
||||
|
|
@ -22,17 +23,17 @@ void module_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_
|
|||
}
|
||||
|
||||
const mp_obj_type_t module_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "module",
|
||||
{ &mp_const_type },
|
||||
"module",
|
||||
.print = module_print,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_module(qstr module_name) {
|
||||
mp_obj_module_t *o = m_new_obj(mp_obj_module_t);
|
||||
o->base.type = &module_type;
|
||||
o->name = module_name;
|
||||
o->globals = mp_map_new(MP_MAP_QSTR, 0);
|
||||
o->globals = mp_map_new(MP_MAP_QSTR, 1);
|
||||
mp_qstr_map_lookup(o->globals, MP_QSTR___name__, true)->value = mp_obj_new_str(module_name);
|
||||
return o;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -18,7 +18,6 @@ const mp_obj_type_t none_type = {
|
|||
.base = { &mp_const_type },
|
||||
.name = "NoneType",
|
||||
.print = none_print,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
static const mp_obj_none_t none_obj = {{&none_type}};
|
||||
|
|
|
|||
|
|
@ -23,10 +23,9 @@ mp_obj_t range_getiter(mp_obj_t o_in) {
|
|||
}
|
||||
|
||||
static const mp_obj_type_t range_type = {
|
||||
.base = { &mp_const_type} ,
|
||||
.name = "range",
|
||||
{ &mp_const_type} ,
|
||||
"range",
|
||||
.getiter = range_getiter,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
// range is a class and instances are immutable sequence objects
|
||||
|
|
@ -62,10 +61,9 @@ mp_obj_t range_it_iternext(mp_obj_t o_in) {
|
|||
}
|
||||
|
||||
static const mp_obj_type_t range_it_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "range_iterator",
|
||||
{ &mp_const_type },
|
||||
"range_iterator",
|
||||
.iternext = range_it_iternext,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_range_iterator(int cur, int stop, int step) {
|
||||
|
|
|
|||
|
|
@ -55,11 +55,10 @@ static mp_obj_t set_make_new(mp_obj_t type_in, int n_args, const mp_obj_t *args)
|
|||
}
|
||||
|
||||
const mp_obj_type_t set_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "set",
|
||||
{ &mp_const_type },
|
||||
"set",
|
||||
.print = set_print,
|
||||
.make_new = set_make_new,
|
||||
.methods = { { NULL, NULL }, },
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_set(int n_args, mp_obj_t *items) {
|
||||
|
|
|
|||
|
|
@ -21,10 +21,9 @@ void ellipsis_print(void (*print)(void *env, const char *fmt, ...), void *env, m
|
|||
}
|
||||
|
||||
const mp_obj_type_t ellipsis_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "ellipsis",
|
||||
{ &mp_const_type },
|
||||
"ellipsis",
|
||||
.print = ellipsis_print,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
static const mp_obj_ellipsis_t ellipsis_obj = {{&ellipsis_type}};
|
||||
|
|
@ -52,7 +51,6 @@ const mp_obj_type_t slice_type = {
|
|||
.base = { &mp_const_type },
|
||||
.name = "slice",
|
||||
.print = slice_print,
|
||||
.methods = { { NULL, NULL }, },
|
||||
};
|
||||
|
||||
// TODO: Make sure to handle "empty" values, which are signified by None in CPython
|
||||
|
|
|
|||
13
py/objstr.c
13
py/objstr.c
|
|
@ -184,17 +184,19 @@ mp_obj_t str_format(int n_args, const mp_obj_t *args) {
|
|||
static MP_DEFINE_CONST_FUN_OBJ_2(str_join_obj, str_join);
|
||||
static MP_DEFINE_CONST_FUN_OBJ_VAR(str_format_obj, 1, str_format);
|
||||
|
||||
static const mp_method_t str_type_methods[] = {
|
||||
{ "join", &str_join_obj },
|
||||
{ "format", &str_format_obj },
|
||||
{ NULL, NULL }, // end-of-list sentinel
|
||||
};
|
||||
|
||||
const mp_obj_type_t str_type = {
|
||||
.base = { &mp_const_type },
|
||||
.name = "str",
|
||||
.print = str_print,
|
||||
.binary_op = str_binary_op,
|
||||
.getiter = str_getiter,
|
||||
.methods = {
|
||||
{ "join", &str_join_obj },
|
||||
{ "format", &str_format_obj },
|
||||
{ NULL, NULL }, // end-of-list sentinel
|
||||
},
|
||||
.methods = str_type_methods,
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_str(qstr qstr) {
|
||||
|
|
@ -235,7 +237,6 @@ static const mp_obj_type_t str_it_type = {
|
|||
.base = { &mp_const_type },
|
||||
.name = "str_iterator",
|
||||
.iternext = str_it_iternext,
|
||||
.methods = { { NULL, NULL }, },
|
||||
};
|
||||
|
||||
mp_obj_t mp_obj_new_str_iterator(mp_obj_str_t *str, int cur) {
|
||||
|
|
|
|||
|
|
@ -103,7 +103,6 @@ const mp_obj_type_t tuple_type = {
|
|||
.make_new = tuple_make_new,
|
||||
.binary_op = tuple_binary_op,
|
||||
.getiter = tuple_getiter,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
// the zero-length tuple
|
||||
|
|
@ -166,7 +165,6 @@ static const mp_obj_type_t tuple_it_type = {
|
|||
.base = { &mp_const_type },
|
||||
.name = "tuple_iterator",
|
||||
.iternext = tuple_it_iternext,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
||||
static mp_obj_t mp_obj_new_tuple_iterator(mp_obj_tuple_t *tuple, int cur) {
|
||||
|
|
|
|||
|
|
@ -27,5 +27,4 @@ const mp_obj_type_t mp_const_type = {
|
|||
.name = "type",
|
||||
.print = type_print,
|
||||
.call_n = type_call_n,
|
||||
.methods = {{NULL, NULL},},
|
||||
};
|
||||
|
|
|
|||
|
|
@ -0,0 +1,105 @@
|
|||
# default settings; can be overriden in main Makefile
|
||||
|
||||
ifndef PY_SRC
|
||||
PY_SRC = ../py
|
||||
endif
|
||||
|
||||
ifndef BUILD
|
||||
BUILD = build
|
||||
endif
|
||||
|
||||
# to create the build directory
|
||||
|
||||
$(BUILD):
|
||||
mkdir -p $@
|
||||
|
||||
# where py object files go (they have a name prefix to prevent filename clashes)
|
||||
|
||||
PY_BUILD = $(BUILD)/py.
|
||||
|
||||
# py object files
|
||||
|
||||
PY_O_BASENAME = \
|
||||
nlrx86.o \
|
||||
nlrx64.o \
|
||||
nlrthumb.o \
|
||||
malloc.o \
|
||||
gc.o \
|
||||
qstr.o \
|
||||
vstr.o \
|
||||
unicode.o \
|
||||
lexer.o \
|
||||
lexerunix.o \
|
||||
parse.o \
|
||||
scope.o \
|
||||
compile.o \
|
||||
emitcommon.o \
|
||||
emitpass1.o \
|
||||
emitcpy.o \
|
||||
emitbc.o \
|
||||
asmx64.o \
|
||||
emitnx64.o \
|
||||
asmthumb.o \
|
||||
emitnthumb.o \
|
||||
emitinlinethumb.o \
|
||||
runtime.o \
|
||||
map.o \
|
||||
obj.o \
|
||||
objbool.o \
|
||||
objboundmeth.o \
|
||||
objcell.o \
|
||||
objclass.o \
|
||||
objclosure.o \
|
||||
objcomplex.o \
|
||||
objdict.o \
|
||||
objexcept.o \
|
||||
objfloat.o \
|
||||
objfun.o \
|
||||
objgenerator.o \
|
||||
objinstance.o \
|
||||
objint.o \
|
||||
objlist.o \
|
||||
objmodule.o \
|
||||
objnone.o \
|
||||
objrange.o \
|
||||
objset.o \
|
||||
objslice.o \
|
||||
objstr.o \
|
||||
objtuple.o \
|
||||
objtype.o \
|
||||
builtin.o \
|
||||
builtinimport.o \
|
||||
vm.o \
|
||||
showbc.o \
|
||||
repl.o \
|
||||
|
||||
# prepend the build destination prefix to the py object files
|
||||
|
||||
PY_O = $(addprefix $(PY_BUILD), $(PY_O_BASENAME))
|
||||
|
||||
$(PY_BUILD)emitnx64.o: $(PY_SRC)/emitnative.c $(PY_SRC)/emit.h mpconfigport.h
|
||||
$(CC) $(CFLAGS) -DN_X64 -c -o $@ $<
|
||||
|
||||
$(PY_BUILD)emitnthumb.o: $(PY_SRC)/emitnative.c $(PY_SRC)/emit.h mpconfigport.h
|
||||
$(CC) $(CFLAGS) -DN_THUMB -c -o $@ $<
|
||||
|
||||
$(PY_BUILD)%.o: $(PY_SRC)/%.S
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(PY_BUILD)%.o: $(PY_SRC)/%.c mpconfigport.h
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
# optimising gc for speed; 5ms down to 4ms on pybv2
|
||||
$(PY_BUILD)gc.o: $(PY_SRC)/gc.c
|
||||
$(CC) $(CFLAGS) -O3 -c -o $@ $<
|
||||
|
||||
# optimising vm for speed, adds only a small amount to code size but makes a huge difference to speed (20% faster)
|
||||
$(PY_BUILD)vm.o: $(PY_SRC)/vm.c
|
||||
$(CC) $(CFLAGS) -O3 -c -o $@ $<
|
||||
|
||||
# header dependencies
|
||||
|
||||
$(PY_BUILD)parse.o: $(PY_SRC)/grammar.h
|
||||
$(PY_BUILD)compile.o: $(PY_SRC)/grammar.h
|
||||
$(PY_BUILD)/emitcpy.o: $(PY_SRC)/emit.h
|
||||
$(PY_BUILD)emitbc.o: $(PY_SRC)/emit.h
|
||||
|
|
@ -1,6 +1,9 @@
|
|||
#include "misc.h"
|
||||
#include "mpconfig.h"
|
||||
#include "repl.h"
|
||||
|
||||
#if MICROPY_ENABLE_REPL_HELPERS
|
||||
|
||||
bool str_startswith_word(const char *str, const char *head) {
|
||||
int i;
|
||||
for (i = 0; str[i] && head[i]; i++) {
|
||||
|
|
@ -42,3 +45,5 @@ bool mp_repl_is_compound_stmt(const char *line) {
|
|||
}
|
||||
return n_paren > 0 || n_brack > 0 || n_brace > 0;
|
||||
}
|
||||
|
||||
#endif // MICROPY_ENABLE_REPL_HELPERS
|
||||
|
|
|
|||
|
|
@ -1 +1,3 @@
|
|||
#if MICROPY_ENABLE_REPL_HELPERS
|
||||
bool mp_repl_is_compound_stmt(const char *line);
|
||||
#endif
|
||||
|
|
|
|||
43
py/runtime.c
43
py/runtime.c
|
|
@ -61,7 +61,8 @@ typedef struct _mp_code_t {
|
|||
} mp_code_t;
|
||||
|
||||
static int next_unique_code_id;
|
||||
static mp_code_t *unique_codes;
|
||||
static machine_uint_t unique_codes_alloc = 0;
|
||||
static mp_code_t *unique_codes = NULL;
|
||||
|
||||
#ifdef WRITE_CODE
|
||||
FILE *fp_write_code = NULL;
|
||||
|
|
@ -126,6 +127,7 @@ void rt_init(void) {
|
|||
mp_qstr_map_lookup(&map_builtins, MP_QSTR_sum, true)->value = rt_make_function_var(1, mp_builtin_sum);
|
||||
|
||||
next_unique_code_id = 1; // 0 indicates "no code"
|
||||
unique_codes_alloc = 0;
|
||||
unique_codes = NULL;
|
||||
|
||||
#ifdef WRITE_CODE
|
||||
|
|
@ -134,6 +136,7 @@ void rt_init(void) {
|
|||
}
|
||||
|
||||
void rt_deinit(void) {
|
||||
m_del(mp_code_t, unique_codes, unique_codes_alloc);
|
||||
#ifdef WRITE_CODE
|
||||
if (fp_write_code != NULL) {
|
||||
fclose(fp_write_code);
|
||||
|
|
@ -146,18 +149,20 @@ int rt_get_unique_code_id(void) {
|
|||
}
|
||||
|
||||
static void alloc_unique_codes(void) {
|
||||
if (unique_codes == NULL) {
|
||||
unique_codes = m_new(mp_code_t, next_unique_code_id + 10); // XXX hack until we fix the REPL allocation problem
|
||||
for (int i = 0; i < next_unique_code_id; i++) {
|
||||
if (next_unique_code_id > unique_codes_alloc) {
|
||||
// increase size of unique_codes table
|
||||
unique_codes = m_renew(mp_code_t, unique_codes, unique_codes_alloc, next_unique_code_id);
|
||||
for (int i = unique_codes_alloc; i < next_unique_code_id; i++) {
|
||||
unique_codes[i].kind = MP_CODE_NONE;
|
||||
}
|
||||
unique_codes_alloc = next_unique_code_id;
|
||||
}
|
||||
}
|
||||
|
||||
void rt_assign_byte_code(int unique_code_id, byte *code, uint len, int n_args, int n_locals, int n_stack, bool is_generator) {
|
||||
alloc_unique_codes();
|
||||
|
||||
assert(1 <= unique_code_id && unique_code_id < next_unique_code_id);
|
||||
assert(1 <= unique_code_id && unique_code_id < next_unique_code_id && unique_codes[unique_code_id].kind == MP_CODE_NONE);
|
||||
unique_codes[unique_code_id].kind = MP_CODE_BYTE;
|
||||
unique_codes[unique_code_id].n_args = n_args;
|
||||
unique_codes[unique_code_id].n_locals = n_locals;
|
||||
|
|
@ -192,7 +197,7 @@ void rt_assign_byte_code(int unique_code_id, byte *code, uint len, int n_args, i
|
|||
void rt_assign_native_code(int unique_code_id, void *fun, uint len, int n_args) {
|
||||
alloc_unique_codes();
|
||||
|
||||
assert(1 <= unique_code_id && unique_code_id < next_unique_code_id);
|
||||
assert(1 <= unique_code_id && unique_code_id < next_unique_code_id && unique_codes[unique_code_id].kind == MP_CODE_NONE);
|
||||
unique_codes[unique_code_id].kind = MP_CODE_NATIVE;
|
||||
unique_codes[unique_code_id].n_args = n_args;
|
||||
unique_codes[unique_code_id].n_locals = 0;
|
||||
|
|
@ -225,7 +230,7 @@ void rt_assign_native_code(int unique_code_id, void *fun, uint len, int n_args)
|
|||
void rt_assign_inline_asm_code(int unique_code_id, void *fun, uint len, int n_args) {
|
||||
alloc_unique_codes();
|
||||
|
||||
assert(1 <= unique_code_id && unique_code_id < next_unique_code_id);
|
||||
assert(1 <= unique_code_id && unique_code_id < next_unique_code_id && unique_codes[unique_code_id].kind == MP_CODE_NONE);
|
||||
unique_codes[unique_code_id].kind = MP_CODE_INLINE_ASM;
|
||||
unique_codes[unique_code_id].n_args = n_args;
|
||||
unique_codes[unique_code_id].n_locals = 0;
|
||||
|
|
@ -785,10 +790,12 @@ mp_obj_t rt_load_attr(mp_obj_t base, qstr attr) {
|
|||
} else if (MP_OBJ_IS_OBJ(base)) {
|
||||
// generic method lookup
|
||||
mp_obj_base_t *o = base;
|
||||
const mp_method_t *meth = &o->type->methods[0];
|
||||
for (; meth->name != NULL; meth++) {
|
||||
if (strcmp(meth->name, qstr_str(attr)) == 0) {
|
||||
return mp_obj_new_bound_meth(base, (mp_obj_t)meth->fun);
|
||||
const mp_method_t *meth = o->type->methods;
|
||||
if (meth != NULL) {
|
||||
for (; meth->name != NULL; meth++) {
|
||||
if (strcmp(meth->name, qstr_str(attr)) == 0) {
|
||||
return mp_obj_new_bound_meth(base, (mp_obj_t)meth->fun);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -809,12 +816,14 @@ void rt_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) {
|
|||
} else if (MP_OBJ_IS_OBJ(base)) {
|
||||
// generic method lookup
|
||||
mp_obj_base_t *o = base;
|
||||
const mp_method_t *meth = &o->type->methods[0];
|
||||
for (; meth->name != NULL; meth++) {
|
||||
if (strcmp(meth->name, qstr_str(attr)) == 0) {
|
||||
dest[1] = (mp_obj_t)meth->fun;
|
||||
dest[0] = base;
|
||||
return;
|
||||
const mp_method_t *meth = o->type->methods;
|
||||
if (meth != NULL) {
|
||||
for (; meth->name != NULL; meth++) {
|
||||
if (strcmp(meth->name, qstr_str(attr)) == 0) {
|
||||
dest[1] = (mp_obj_t)meth->fun;
|
||||
dest[0] = base;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,6 +8,8 @@
|
|||
#include "mpconfig.h"
|
||||
#include "bc0.h"
|
||||
|
||||
#if MICROPY_SHOW_BC
|
||||
|
||||
#define DECODE_UINT do { unum = *ip++; if (unum > 127) { unum = ((unum & 0x3f) << 8) | (*ip++); } } while (0)
|
||||
#define DECODE_ULABEL do { unum = (ip[0] | (ip[1] << 8)); ip += 2; } while (0)
|
||||
#define DECODE_SLABEL do { unum = (ip[0] | (ip[1] << 8)) - 0x8000; ip += 2; } while (0)
|
||||
|
|
@ -363,3 +365,5 @@ void mp_show_byte_code(const byte *ip, int len) {
|
|||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
#endif // MICROPY_SHOW_BC
|
||||
|
|
|
|||
95
stm/Makefile
95
stm/Makefile
|
|
@ -1,9 +1,16 @@
|
|||
# define main target
|
||||
all: all2
|
||||
|
||||
# include py core make definitions
|
||||
include ../py/py.mk
|
||||
|
||||
# program for deletion
|
||||
RM = /bin/rm
|
||||
|
||||
STMSRC=lib
|
||||
#STMOTGSRC=lib-otg
|
||||
FATFSSRC=fatfs
|
||||
CC3KSRC=cc3k
|
||||
PYSRC=../py
|
||||
BUILD=build
|
||||
DFU=../tools/dfu.py
|
||||
TARGET=PYBOARD
|
||||
|
||||
|
|
@ -11,7 +18,7 @@ AS = arm-none-eabi-as
|
|||
CC = arm-none-eabi-gcc
|
||||
LD = arm-none-eabi-ld
|
||||
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 -DSTM32F40XX -DHSE_VALUE=8000000
|
||||
CFLAGS = -I. -I$(PYSRC) -I$(FATFSSRC) -I$(STMSRC) -Wall -ansi -std=gnu99 -Os -DNDEBUG $(CFLAGS_CORTEX_M4) -D$(TARGET)
|
||||
CFLAGS = -I. -I$(PY_SRC) -I$(FATFSSRC) -I$(STMSRC) -Wall -ansi -std=gnu99 -Os -DNDEBUG $(CFLAGS_CORTEX_M4) -D$(TARGET)
|
||||
#CFLAGS += -I$(STMOTGSRC) -DUSE_HOST_MODE -DUSE_OTG_MODE
|
||||
LDFLAGS = --nostdlib -T stm32f405.ld
|
||||
|
||||
|
|
@ -43,53 +50,6 @@ SRC_S = \
|
|||
startup_stm32f40xx.s \
|
||||
gchelper.s \
|
||||
|
||||
PY_O = \
|
||||
nlrthumb.o \
|
||||
gc.o \
|
||||
malloc.o \
|
||||
qstr.o \
|
||||
vstr.o \
|
||||
unicode.o \
|
||||
lexer.o \
|
||||
parse.o \
|
||||
scope.o \
|
||||
compile.o \
|
||||
emitcommon.o \
|
||||
emitpass1.o \
|
||||
emitbc.o \
|
||||
asmthumb.o \
|
||||
emitnthumb.o \
|
||||
emitinlinethumb.o \
|
||||
runtime.o \
|
||||
map.o \
|
||||
obj.o \
|
||||
objbool.o \
|
||||
objboundmeth.o \
|
||||
objcell.o \
|
||||
objclass.o \
|
||||
objclosure.o \
|
||||
objcomplex.o \
|
||||
objdict.o \
|
||||
objexcept.o \
|
||||
objfloat.o \
|
||||
objfun.o \
|
||||
objgenerator.o \
|
||||
objinstance.o \
|
||||
objint.o \
|
||||
objlist.o \
|
||||
objmodule.o \
|
||||
objnone.o \
|
||||
objrange.o \
|
||||
objset.o \
|
||||
objslice.o \
|
||||
objstr.o \
|
||||
objtuple.o \
|
||||
objtype.o \
|
||||
builtin.o \
|
||||
builtinimport.o \
|
||||
vm.o \
|
||||
repl.o \
|
||||
|
||||
SRC_FATFS = \
|
||||
ff.c \
|
||||
diskio.c \
|
||||
|
|
@ -146,10 +106,10 @@ SRC_CC3K = \
|
|||
ccspi.c \
|
||||
pybcc3k.c \
|
||||
|
||||
OBJ = $(addprefix $(BUILD)/, $(SRC_C:.c=.o) $(SRC_S:.s=.o) $(PY_O) $(SRC_FATFS:.c=.o) $(SRC_STM:.c=.o) $(SRC_CC3K:.c=.o))
|
||||
OBJ = $(addprefix $(BUILD)/, $(SRC_C:.c=.o) $(SRC_S:.s=.o) $(SRC_FATFS:.c=.o) $(SRC_STM:.c=.o) $(SRC_CC3K:.c=.o)) $(PY_O)
|
||||
#OBJ += $(addprefix $(BUILD)/, $(SRC_STM_OTG:.c=.o))
|
||||
|
||||
all: $(BUILD) $(BUILD)/flash.dfu
|
||||
all2: $(BUILD) $(BUILD)/flash.dfu
|
||||
|
||||
$(BUILD)/flash.dfu: $(BUILD)/flash0.bin $(BUILD)/flash1.bin
|
||||
python $(DFU) -b 0x08000000:$(BUILD)/flash0.bin -b 0x08020000:$(BUILD)/flash1.bin $@
|
||||
|
|
@ -164,9 +124,6 @@ $(BUILD)/flash.elf: $(OBJ)
|
|||
$(LD) $(LDFLAGS) -o $@ $(OBJ)
|
||||
arm-none-eabi-size $@
|
||||
|
||||
$(BUILD):
|
||||
mkdir -p $@
|
||||
|
||||
$(BUILD)/%.o: %.s
|
||||
$(AS) -o $@ $<
|
||||
|
||||
|
|
@ -185,31 +142,7 @@ $(BUILD)/%.o: $(STMSRC)/%.c
|
|||
$(BUILD)/%.o: $(CC3KSRC)/%.c
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(BUILD)/%.o: $(PYSRC)/%.s
|
||||
$(AS) -o $@ $<
|
||||
|
||||
$(BUILD)/%.o: $(PYSRC)/%.S
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(BUILD)/%.o: $(PYSRC)/%.c mpconfigport.h
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(BUILD)/emitnthumb.o: $(PYSRC)/emitnative.c $(PYSRC)/emit.h
|
||||
$(CC) $(CFLAGS) -DN_THUMB -c -o $@ $<
|
||||
|
||||
# optimising gc for speed; 5ms down to 4ms
|
||||
$(BUILD)/gc.o: $(PYSRC)/gc.c
|
||||
$(CC) $(CFLAGS) -O3 -c -o $@ $<
|
||||
|
||||
# optimising vm for speed, adds only a small amount to code size but makes a huge difference to speed (20% faster)
|
||||
$(BUILD)/vm.o: $(PYSRC)/vm.c
|
||||
$(CC) $(CFLAGS) -O3 -c -o $@ $<
|
||||
|
||||
$(BUILD)/parse.o: $(PYSRC)/grammar.h
|
||||
$(BUILD)/compile.o: $(PYSRC)/grammar.h
|
||||
$(BUILD)/emitbc.o: $(PYSRC)/emit.h
|
||||
|
||||
clean:
|
||||
/bin/rm -rf $(BUILD)
|
||||
$(RM) -rf $(BUILD)
|
||||
|
||||
.PHONY: all clean
|
||||
.PHONY: all all2 clean
|
||||
|
|
|
|||
18
stm/i2c.c
18
stm/i2c.c
|
|
@ -326,18 +326,20 @@ static MP_DEFINE_CONST_FUN_OBJ_1(i2c_obj_read_obj, i2c_obj_read);
|
|||
static MP_DEFINE_CONST_FUN_OBJ_1(i2c_obj_readAndStop_obj, i2c_obj_readAndStop);
|
||||
static MP_DEFINE_CONST_FUN_OBJ_1(i2c_obj_stop_obj, i2c_obj_stop);
|
||||
|
||||
static const mp_method_t i2c_methods[] = {
|
||||
{ "start", &i2c_obj_start_obj },
|
||||
{ "write", &i2c_obj_write_obj },
|
||||
{ "read", &i2c_obj_read_obj },
|
||||
{ "readAndStop", &i2c_obj_readAndStop_obj },
|
||||
{ "stop", &i2c_obj_stop_obj },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static const mp_obj_type_t i2c_obj_type = {
|
||||
{ &mp_const_type },
|
||||
"I2C",
|
||||
.print = i2c_obj_print,
|
||||
.methods = {
|
||||
{ "start", &i2c_obj_start_obj },
|
||||
{ "write", &i2c_obj_write_obj },
|
||||
{ "read", &i2c_obj_read_obj },
|
||||
{ "readAndStop", &i2c_obj_readAndStop_obj },
|
||||
{ "stop", &i2c_obj_stop_obj },
|
||||
{ NULL, NULL },
|
||||
}
|
||||
.methods = i2c_methods,
|
||||
};
|
||||
|
||||
// create the I2C object
|
||||
|
|
|
|||
12
stm/led.c
12
stm/led.c
|
|
@ -176,15 +176,17 @@ mp_obj_t led_obj_off(mp_obj_t self_in) {
|
|||
static MP_DEFINE_CONST_FUN_OBJ_1(led_obj_on_obj, led_obj_on);
|
||||
static MP_DEFINE_CONST_FUN_OBJ_1(led_obj_off_obj, led_obj_off);
|
||||
|
||||
static const mp_method_t led_methods[] = {
|
||||
{ "on", &led_obj_on_obj },
|
||||
{ "off", &led_obj_off_obj },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static const mp_obj_type_t led_obj_type = {
|
||||
{ &mp_const_type },
|
||||
"Led",
|
||||
.print = led_obj_print,
|
||||
.methods = {
|
||||
{ "on", &led_obj_on_obj },
|
||||
{ "off", &led_obj_off_obj },
|
||||
{ NULL, NULL },
|
||||
}
|
||||
.methods = led_methods,
|
||||
};
|
||||
|
||||
mp_obj_t pyb_Led(mp_obj_t led_id) {
|
||||
|
|
|
|||
22
stm/main.c
22
stm/main.c
|
|
@ -689,22 +689,18 @@ static MP_DEFINE_CONST_FUN_OBJ_1(file_obj_close_obj, file_obj_close);
|
|||
|
||||
// TODO gc hook to close the file if not already closed
|
||||
|
||||
static const mp_method_t file_methods[] = {
|
||||
{ "read", &file_obj_read_obj },
|
||||
{ "write", &file_obj_write_obj },
|
||||
{ "close", &file_obj_close_obj },
|
||||
{NULL, NULL},
|
||||
};
|
||||
|
||||
static const mp_obj_type_t file_obj_type = {
|
||||
{ &mp_const_type },
|
||||
"File",
|
||||
file_obj_print, // print
|
||||
NULL, // make_new
|
||||
NULL, // call_n
|
||||
NULL, // unary_op
|
||||
NULL, // binary_op
|
||||
NULL, // getiter
|
||||
NULL, // iternext
|
||||
.methods = {
|
||||
{ "read", &file_obj_read_obj },
|
||||
{ "write", &file_obj_write_obj },
|
||||
{ "close", &file_obj_close_obj },
|
||||
{NULL, NULL},
|
||||
}
|
||||
.print = file_obj_print,
|
||||
.methods = file_methods,
|
||||
};
|
||||
|
||||
mp_obj_t pyb_io_open(mp_obj_t o_filename, mp_obj_t o_mode) {
|
||||
|
|
|
|||
|
|
@ -2,11 +2,11 @@
|
|||
|
||||
// options to control how Micro Python is built
|
||||
|
||||
#define MICROPY_ENABLE_FLOAT (1)
|
||||
#define MICROPY_EMIT_CPYTHON (0)
|
||||
#define MICROPY_EMIT_X64 (0)
|
||||
#define MICROPY_EMIT_THUMB (1)
|
||||
#define MICROPY_EMIT_INLINE_THUMB (1)
|
||||
#define MICROPY_ENABLE_GC (1)
|
||||
#define MICROPY_ENABLE_REPL_HELPERS (1)
|
||||
#define MICROPY_ENABLE_FLOAT (1)
|
||||
|
||||
// type definitions for the specific machine
|
||||
|
||||
|
|
|
|||
10
stm/servo.c
10
stm/servo.c
|
|
@ -137,14 +137,16 @@ static mp_obj_t servo_obj_angle(mp_obj_t self_in, mp_obj_t angle) {
|
|||
|
||||
static MP_DEFINE_CONST_FUN_OBJ_2(servo_obj_angle_obj, servo_obj_angle);
|
||||
|
||||
static const mp_method_t servo_methods[] = {
|
||||
{ "angle", &servo_obj_angle_obj },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static const mp_obj_type_t servo_obj_type = {
|
||||
{ &mp_const_type },
|
||||
"Servo",
|
||||
.print = servo_obj_print,
|
||||
.methods = {
|
||||
{ "angle", &servo_obj_angle_obj },
|
||||
{ NULL, NULL },
|
||||
}
|
||||
.methods = servo_methods,
|
||||
};
|
||||
|
||||
mp_obj_t pyb_Servo(mp_obj_t servo_id) {
|
||||
|
|
|
|||
|
|
@ -1,95 +1,37 @@
|
|||
PYSRC=../py
|
||||
BUILD=build
|
||||
# define main target
|
||||
PROG = cpy
|
||||
all: $(PROG)
|
||||
|
||||
# include py core make definitions
|
||||
include ../py/py.mk
|
||||
|
||||
# program for deletion
|
||||
RM = /bin/rm
|
||||
|
||||
# compiler settings
|
||||
CC = gcc
|
||||
CFLAGS = -I. -I$(PYSRC) -Wall -Werror -ansi -std=gnu99 -Os #-DNDEBUG
|
||||
CFLAGS = -I. -I$(PY_SRC) -Wall -Werror -ansi -std=gnu99 -Os #-DNDEBUG
|
||||
LDFLAGS = -lm
|
||||
|
||||
# source files
|
||||
SRC_C = \
|
||||
main.c \
|
||||
|
||||
PY_O = \
|
||||
nlrx86.o \
|
||||
nlrx64.o \
|
||||
malloc.o \
|
||||
qstr.o \
|
||||
vstr.o \
|
||||
unicode.o \
|
||||
lexer.o \
|
||||
lexerunix.o \
|
||||
parse.o \
|
||||
scope.o \
|
||||
compile.o \
|
||||
emitcommon.o \
|
||||
emitpass1.o \
|
||||
emitcpy.o \
|
||||
runtime.o \
|
||||
map.o \
|
||||
obj.o \
|
||||
objbool.o \
|
||||
objboundmeth.o \
|
||||
objcell.o \
|
||||
objclass.o \
|
||||
objclosure.o \
|
||||
objcomplex.o \
|
||||
objdict.o \
|
||||
objexcept.o \
|
||||
objfloat.o \
|
||||
objfun.o \
|
||||
objgenerator.o \
|
||||
objinstance.o \
|
||||
objint.o \
|
||||
objlist.o \
|
||||
objmodule.o \
|
||||
objnone.o \
|
||||
objrange.o \
|
||||
objset.o \
|
||||
objslice.o \
|
||||
objstr.o \
|
||||
objtuple.o \
|
||||
objtype.o \
|
||||
builtin.o \
|
||||
builtinimport.o \
|
||||
vm.o \
|
||||
showbc.o \
|
||||
repl.o \
|
||||
|
||||
OBJ = $(addprefix $(BUILD)/, $(SRC_C:.c=.o) $(PY_O))
|
||||
OBJ = $(addprefix $(BUILD)/, $(SRC_C:.c=.o)) $(PY_O)
|
||||
LIB =
|
||||
PROG = cpy
|
||||
|
||||
$(PROG): $(BUILD) $(OBJ)
|
||||
$(CC) -o $@ $(OBJ) $(LIB) $(LDFLAGS)
|
||||
|
||||
$(BUILD):
|
||||
mkdir -p $@
|
||||
strip $(PROG)
|
||||
size $(PROG)
|
||||
|
||||
$(BUILD)/%.o: %.c
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(BUILD)/%.o: $(PYSRC)/%.S
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(BUILD)/%.o: $(PYSRC)/%.c mpconfigport.h
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(BUILD)/emitnx64.o: $(PYSRC)/emitnative.c $(PYSRC)/emit.h
|
||||
$(CC) $(CFLAGS) -DN_X64 -c -o $@ $<
|
||||
|
||||
$(BUILD)/emitnthumb.o: $(PYSRC)/emitnative.c $(PYSRC)/emit.h
|
||||
$(CC) $(CFLAGS) -DN_THUMB -c -o $@ $<
|
||||
|
||||
# optimising vm for speed, adds only a small amount to code size but makes a huge difference to speed (20% faster)
|
||||
$(BUILD)/vm.o: $(PYSRC)/vm.c
|
||||
$(CC) $(CFLAGS) -O3 -c -o $@ $<
|
||||
|
||||
$(BUILD)/main.o: mpconfigport.h
|
||||
$(BUILD)/parse.o: $(PYSRC)/grammar.h
|
||||
$(BUILD)/compile.o: $(PYSRC)/grammar.h
|
||||
$(BUILD)/emitcpy.o: $(PYSRC)/emit.h
|
||||
$(BUILD)/emitbc.o: $(PYSRC)/emit.h
|
||||
|
||||
clean:
|
||||
/bin/rm -rf $(BUILD)
|
||||
$(RM) -f $(PROG)
|
||||
$(RM) -rf $(BUILD)
|
||||
|
||||
.PHONY: clean
|
||||
.PHONY: all clean
|
||||
|
|
|
|||
|
|
@ -11,7 +11,6 @@
|
|||
#include "obj.h"
|
||||
#include "compile.h"
|
||||
#include "runtime0.h"
|
||||
#include "runtime.h"
|
||||
|
||||
void do_file(const char *file) {
|
||||
mp_lexer_t *lex = mp_lexer_new_from_file(file);
|
||||
|
|
|
|||
|
|
@ -1,10 +1,8 @@
|
|||
// options to control how Micro Python is built
|
||||
|
||||
#define MICROPY_ENABLE_FLOAT (1)
|
||||
#define MICROPY_EMIT_CPYTHON (1)
|
||||
#define MICROPY_EMIT_X64 (0)
|
||||
#define MICROPY_EMIT_THUMB (0)
|
||||
#define MICROPY_EMIT_INLINE_THUMB (0)
|
||||
#define MICROPY_ENABLE_LEXER_UNIX (1)
|
||||
#define MICROPY_ENABLE_FLOAT (1)
|
||||
|
||||
// type definitions for the specific machine
|
||||
|
||||
|
|
|
|||
|
|
@ -1,106 +1,39 @@
|
|||
PYSRC=../py
|
||||
BUILD=build
|
||||
# define main target
|
||||
PROG = py
|
||||
all: $(PROG)
|
||||
|
||||
# include py core make definitions
|
||||
include ../py/py.mk
|
||||
|
||||
# program for deletion
|
||||
RM = /bin/rm
|
||||
|
||||
# compiler settings
|
||||
CC = gcc
|
||||
CFLAGS = -I. -I$(PYSRC) -Wall -Werror -ansi -std=gnu99 -Os #-DNDEBUG
|
||||
CFLAGS = -I. -I$(PY_SRC) -Wall -Werror -ansi -std=gnu99 -Os #-DNDEBUG
|
||||
LDFLAGS = -lm
|
||||
|
||||
# source files
|
||||
SRC_C = \
|
||||
main.c \
|
||||
|
||||
PY_O = \
|
||||
nlrx86.o \
|
||||
nlrx64.o \
|
||||
nlrthumb.o \
|
||||
malloc.o \
|
||||
qstr.o \
|
||||
vstr.o \
|
||||
unicode.o \
|
||||
lexer.o \
|
||||
lexerunix.o \
|
||||
parse.o \
|
||||
scope.o \
|
||||
compile.o \
|
||||
emitcommon.o \
|
||||
emitpass1.o \
|
||||
emitcpy.o \
|
||||
emitbc.o \
|
||||
asmx64.o \
|
||||
emitnx64.o \
|
||||
asmthumb.o \
|
||||
emitnthumb.o \
|
||||
emitinlinethumb.o \
|
||||
runtime.o \
|
||||
map.o \
|
||||
obj.o \
|
||||
objbool.o \
|
||||
objboundmeth.o \
|
||||
objcell.o \
|
||||
objclass.o \
|
||||
objclosure.o \
|
||||
objcomplex.o \
|
||||
objdict.o \
|
||||
objexcept.o \
|
||||
objfloat.o \
|
||||
objfun.o \
|
||||
objgenerator.o \
|
||||
objinstance.o \
|
||||
objint.o \
|
||||
objlist.o \
|
||||
objmodule.o \
|
||||
objnone.o \
|
||||
objrange.o \
|
||||
objset.o \
|
||||
objslice.o \
|
||||
objstr.o \
|
||||
objtuple.o \
|
||||
objtype.o \
|
||||
builtin.o \
|
||||
builtinimport.o \
|
||||
vm.o \
|
||||
showbc.o \
|
||||
repl.o \
|
||||
|
||||
OBJ = $(addprefix $(BUILD)/, $(SRC_C:.c=.o) $(PY_O))
|
||||
OBJ = $(addprefix $(BUILD)/, $(SRC_C:.c=.o)) $(PY_O)
|
||||
LIB = -lreadline
|
||||
# the following is needed for BSD
|
||||
#LIB += -ltermcap
|
||||
PROG = py
|
||||
|
||||
$(PROG): $(BUILD) $(OBJ)
|
||||
$(CC) -o $@ $(OBJ) $(LIB) $(LDFLAGS)
|
||||
strip $(PROG)
|
||||
size $(PROG)
|
||||
|
||||
$(BUILD):
|
||||
mkdir -p $@
|
||||
|
||||
$(BUILD)/%.o: %.c
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(BUILD)/%.o: $(PYSRC)/%.S
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(BUILD)/%.o: $(PYSRC)/%.c mpconfigport.h
|
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(BUILD)/emitnx64.o: $(PYSRC)/emitnative.c $(PYSRC)/emit.h mpconfigport.h
|
||||
$(CC) $(CFLAGS) -DN_X64 -c -o $@ $<
|
||||
|
||||
$(BUILD)/emitnthumb.o: $(PYSRC)/emitnative.c $(PYSRC)/emit.h mpconfigport.h
|
||||
$(CC) $(CFLAGS) -DN_THUMB -c -o $@ $<
|
||||
|
||||
# optimising vm for speed, adds only a small amount to code size but makes a huge difference to speed (20% faster)
|
||||
$(BUILD)/vm.o: $(PYSRC)/vm.c
|
||||
$(CC) $(CFLAGS) -O3 -c -o $@ $<
|
||||
|
||||
$(BUILD)/main.o: mpconfigport.h
|
||||
$(BUILD)/parse.o: $(PYSRC)/grammar.h
|
||||
$(BUILD)/compile.o: $(PYSRC)/grammar.h
|
||||
$(BUILD)/emitcpy.o: $(PYSRC)/emit.h
|
||||
$(BUILD)/emitbc.o: $(PYSRC)/emit.h
|
||||
|
||||
clean:
|
||||
/bin/rm -rf $(BUILD)
|
||||
$(RM) -f $(PROG)
|
||||
$(RM) -rf $(BUILD)
|
||||
|
||||
.PHONY: clean
|
||||
.PHONY: all clean
|
||||
|
|
|
|||
163
unix/main.c
163
unix/main.c
|
|
@ -20,6 +20,52 @@
|
|||
#include <readline/history.h>
|
||||
#endif
|
||||
|
||||
static void execute_from_lexer(mp_lexer_t *lex, mp_parse_input_kind_t input_kind, bool is_repl) {
|
||||
if (lex == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (0) {
|
||||
// just tokenise
|
||||
while (!mp_lexer_is_kind(lex, MP_TOKEN_END)) {
|
||||
mp_token_show(mp_lexer_cur(lex));
|
||||
mp_lexer_to_next(lex);
|
||||
}
|
||||
mp_lexer_free(lex);
|
||||
return;
|
||||
}
|
||||
|
||||
mp_parse_node_t pn = mp_parse(lex, input_kind);
|
||||
mp_lexer_free(lex);
|
||||
|
||||
if (pn == MP_PARSE_NODE_NULL) {
|
||||
// parse error
|
||||
return;
|
||||
}
|
||||
|
||||
//printf("----------------\n");
|
||||
//parse_node_show(pn, 0);
|
||||
//printf("----------------\n");
|
||||
|
||||
mp_obj_t module_fun = mp_compile(pn, is_repl);
|
||||
|
||||
if (module_fun == mp_const_none) {
|
||||
// compile error
|
||||
return;
|
||||
}
|
||||
|
||||
// execute it
|
||||
nlr_buf_t nlr;
|
||||
if (nlr_push(&nlr) == 0) {
|
||||
rt_call_function_0(module_fun);
|
||||
nlr_pop();
|
||||
} else {
|
||||
// uncaught exception
|
||||
mp_obj_print((mp_obj_t)nlr.ret_val);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
static char *str_join(const char *s1, int sep_char, const char *s2) {
|
||||
int l1 = strlen(s1);
|
||||
int l2 = strlen(s2);
|
||||
|
|
@ -80,28 +126,11 @@ static void do_repl(void) {
|
|||
}
|
||||
|
||||
mp_lexer_t *lex = mp_lexer_new_from_str_len("<stdin>", line, strlen(line), false);
|
||||
mp_parse_node_t pn = mp_parse(lex, MP_PARSE_SINGLE_INPUT);
|
||||
mp_lexer_free(lex);
|
||||
|
||||
if (pn != MP_PARSE_NODE_NULL) {
|
||||
//mp_parse_node_show(pn, 0);
|
||||
mp_obj_t module_fun = mp_compile(pn, true);
|
||||
if (module_fun != mp_const_none) {
|
||||
nlr_buf_t nlr;
|
||||
if (nlr_push(&nlr) == 0) {
|
||||
rt_call_function_0(module_fun);
|
||||
nlr_pop();
|
||||
} else {
|
||||
// uncaught exception
|
||||
mp_obj_print((mp_obj_t)nlr.ret_val);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
execute_from_lexer(lex, MP_PARSE_SINGLE_INPUT, true);
|
||||
}
|
||||
}
|
||||
|
||||
void do_file(const char *file) {
|
||||
static void do_file(const char *file) {
|
||||
// hack: set dir for import based on where this file is
|
||||
{
|
||||
const char * s = strrchr(file, '/');
|
||||
|
|
@ -115,58 +144,17 @@ void do_file(const char *file) {
|
|||
}
|
||||
|
||||
mp_lexer_t *lex = mp_lexer_new_from_file(file);
|
||||
//const char *pysrc = "def f():\n x=x+1\n print(42)\n";
|
||||
//mp_lexer_t *lex = mp_lexer_from_str_len("<>", pysrc, strlen(pysrc), false);
|
||||
if (lex == NULL) {
|
||||
return;
|
||||
}
|
||||
execute_from_lexer(lex, MP_PARSE_FILE_INPUT, false);
|
||||
}
|
||||
|
||||
if (0) {
|
||||
// just tokenise
|
||||
while (!mp_lexer_is_kind(lex, MP_TOKEN_END)) {
|
||||
mp_token_show(mp_lexer_cur(lex));
|
||||
mp_lexer_to_next(lex);
|
||||
}
|
||||
mp_lexer_free(lex);
|
||||
|
||||
} else {
|
||||
// compile
|
||||
|
||||
mp_parse_node_t pn = mp_parse(lex, MP_PARSE_FILE_INPUT);
|
||||
mp_lexer_free(lex);
|
||||
|
||||
if (pn != MP_PARSE_NODE_NULL) {
|
||||
//printf("----------------\n");
|
||||
//parse_node_show(pn, 0);
|
||||
//printf("----------------\n");
|
||||
mp_obj_t module_fun = mp_compile(pn, false);
|
||||
//printf("----------------\n");
|
||||
|
||||
#if MICROPY_EMIT_CPYTHON
|
||||
if (!comp_ok) {
|
||||
printf("compile error\n");
|
||||
}
|
||||
#else
|
||||
if (1 && module_fun != mp_const_none) {
|
||||
// execute it
|
||||
nlr_buf_t nlr;
|
||||
if (nlr_push(&nlr) == 0) {
|
||||
rt_call_function_0(module_fun);
|
||||
nlr_pop();
|
||||
} else {
|
||||
// uncaught exception
|
||||
mp_obj_print((mp_obj_t)nlr.ret_val);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
static void do_str(const char *str) {
|
||||
mp_lexer_t *lex = mp_lexer_new_from_str_len("<stdin>", str, strlen(str), false);
|
||||
execute_from_lexer(lex, MP_PARSE_SINGLE_INPUT, false);
|
||||
}
|
||||
|
||||
typedef struct _test_obj_t {
|
||||
mp_obj_base_t base;
|
||||
bool value;
|
||||
int value;
|
||||
} test_obj_t;
|
||||
|
||||
static void test_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in) {
|
||||
|
|
@ -188,21 +176,17 @@ static mp_obj_t test_set(mp_obj_t self_in, mp_obj_t arg) {
|
|||
static MP_DEFINE_CONST_FUN_OBJ_1(test_get_obj, test_get);
|
||||
static MP_DEFINE_CONST_FUN_OBJ_2(test_set_obj, test_set);
|
||||
|
||||
static const mp_method_t test_methods[] = {
|
||||
{ "get", &test_get_obj },
|
||||
{ "set", &test_set_obj },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static const mp_obj_type_t test_type = {
|
||||
{ &mp_const_type },
|
||||
"Test",
|
||||
.print = test_print,
|
||||
.make_new = NULL,
|
||||
.call_n = NULL,
|
||||
.unary_op = NULL,
|
||||
.binary_op = NULL,
|
||||
.getiter = NULL,
|
||||
.iternext = NULL,
|
||||
.methods = {
|
||||
{ "get", &test_get_obj },
|
||||
{ "set", &test_set_obj },
|
||||
{ NULL, NULL },
|
||||
}
|
||||
.methods = test_methods,
|
||||
};
|
||||
|
||||
mp_obj_t test_obj_new(int value) {
|
||||
|
|
@ -212,6 +196,11 @@ mp_obj_t test_obj_new(int value) {
|
|||
return o;
|
||||
}
|
||||
|
||||
int usage(void) {
|
||||
printf("usage: py [-c <command>] [<filename>]\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
qstr_init();
|
||||
rt_init();
|
||||
|
|
@ -227,12 +216,24 @@ int main(int argc, char **argv) {
|
|||
|
||||
if (argc == 1) {
|
||||
do_repl();
|
||||
} else if (argc == 2) {
|
||||
do_file(argv[1]);
|
||||
} else {
|
||||
printf("usage: py [<file>]\n");
|
||||
return 1;
|
||||
for (int a = 1; a < argc; a++) {
|
||||
if (argv[a][0] == '-') {
|
||||
if (strcmp(argv[a], "-c") == 0) {
|
||||
if (a + 1 >= argc) {
|
||||
return usage();
|
||||
}
|
||||
do_str(argv[a + 1]);
|
||||
a += 1;
|
||||
} else {
|
||||
return usage();
|
||||
}
|
||||
} else {
|
||||
do_file(argv[a]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
rt_deinit();
|
||||
|
||||
//printf("total bytes = %d\n", m_get_total_bytes_allocated());
|
||||
|
|
|
|||
|
|
@ -5,11 +5,13 @@
|
|||
#define MICROPY_USE_READLINE (1)
|
||||
#endif
|
||||
|
||||
#define MICROPY_ENABLE_FLOAT (1)
|
||||
#define MICROPY_EMIT_CPYTHON (0)
|
||||
#define MICROPY_EMIT_X64 (1)
|
||||
#define MICROPY_EMIT_THUMB (0)
|
||||
#define MICROPY_EMIT_INLINE_THUMB (0)
|
||||
#define MICROPY_MEM_STATS (1)
|
||||
#define MICROPY_ENABLE_REPL_HELPERS (1)
|
||||
#define MICROPY_ENABLE_LEXER_UNIX (1)
|
||||
#define MICROPY_ENABLE_FLOAT (1)
|
||||
|
||||
// type definitions for the specific machine
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue