mirror
/
micropython
kopia lustrzana https://github.com/micropython/micropython
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

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

pull/235/head
Damien George 2014-01-27 23:16:20 +00:00
rodzic 4e8dc8c41b 9b00dad7bb
commit c7aa9fcae5
7 zmienionych plików z 135 dodań i 12 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

25
py/objgenerator.c
Wyświetl plik

@ -73,8 +73,11 @@ mp_obj_t gen_instance_getiter(mp_obj_t self_in) {
return self_in;
}
static mp_obj_t gen_send(mp_obj_t self_in, mp_obj_t send_value) {
static mp_obj_t gen_next_send(mp_obj_t self_in, mp_obj_t send_value) {
mp_obj_gen_instance_t *self = self_in;
if (self->ip == 0) {
return mp_const_stop_iteration;
}
if (self->sp == self->state - 1) {
if (send_value != mp_const_none) {
nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "can't send non-None value to a just-started generator"));
@ -86,6 +89,12 @@ static mp_obj_t gen_send(mp_obj_t self_in, mp_obj_t send_value) {
if (yield) {
return *self->sp;
} else {
// Explicitly mark generator as completed. If we don't do this,
// subsequent next() may re-execute statements after last yield
// again and again, leading to side effects.
// TODO: check how return with value behaves under such conditions
// in CPython.
self->ip = 0;
if (*self->sp == mp_const_none) {
return mp_const_stop_iteration;
} else {
@ -94,14 +103,22 @@ static mp_obj_t gen_send(mp_obj_t self_in, mp_obj_t send_value) {
}
}
}
static MP_DEFINE_CONST_FUN_OBJ_2(gen_send_obj, gen_send);
mp_obj_t gen_instance_iternext(mp_obj_t self_in) {
return gen_send(self_in, mp_const_none);
return gen_next_send(self_in, mp_const_none);
}
static mp_obj_t gen_instance_send(mp_obj_t self_in, mp_obj_t send_value) {
mp_obj_t ret = gen_next_send(self_in, send_value);
if (ret == mp_const_stop_iteration) {
nlr_jump(mp_obj_new_exception(MP_QSTR_StopIteration));
}
return ret;
}
static MP_DEFINE_CONST_FUN_OBJ_2(gen_instance_send_obj, gen_instance_send);
static const mp_method_t gen_type_methods[] = {
{ "send", &gen_send_obj },
{ "send", &gen_instance_send_obj },
{ NULL, NULL }, // end-of-list sentinel
};

7
py/objint.c
Wyświetl plik

@ -51,6 +51,12 @@ void int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj
}
}
// This is called only for non-SMALL_INT
mp_obj_t int_unary_op(int op, mp_obj_t o_in) {
assert(0);
return mp_const_none;
}
// This is called only for non-SMALL_INT
mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
assert(0);
@ -96,5 +102,6 @@ const mp_obj_type_t int_type = {
"int",
.print = int_print,
.make_new = int_make_new,
.unary_op = int_unary_op,
.binary_op = int_binary_op,
};

1
py/objint.h
Wyświetl plik

@ -6,4 +6,5 @@ typedef struct _mp_obj_int_t {
} mp_obj_int_t;
void int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind);
mp_obj_t int_unary_op(int op, mp_obj_t o_in);
mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in);

41
py/objint_longlong.c
Wyświetl plik

@ -32,6 +32,17 @@ void int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj
}
}
mp_obj_t int_unary_op(int op, mp_obj_t o_in) {
mp_obj_int_t *o = o_in;
switch (op) {
case RT_UNARY_OP_NOT: return MP_BOOL(o->val != 0); // TODO: implements RT_UNARY_OP_BOOL
case RT_UNARY_OP_POSITIVE: return o_in;
case RT_UNARY_OP_NEGATIVE: return mp_obj_new_int_from_ll(-o->val);
case RT_UNARY_OP_INVERT: return mp_obj_new_int_from_ll(~o->val);
default: return NULL; // op not supported
}
}
mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
mp_obj_int_t *lhs = lhs_in;
mp_obj_int_t *rhs = rhs_in;
@ -50,13 +61,23 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
return mp_obj_new_int_from_ll(lhs->val + rhs_val);
case RT_BINARY_OP_SUBTRACT:
return mp_obj_new_int_from_ll(lhs->val - rhs_val);
case RT_BINARY_OP_MULTIPLY:
return mp_obj_new_int_from_ll(lhs->val * rhs_val);
case RT_BINARY_OP_FLOOR_DIVIDE:
return mp_obj_new_int_from_ll(lhs->val / rhs_val);
case RT_BINARY_OP_MODULO:
return mp_obj_new_int_from_ll(lhs->val % rhs_val);
case RT_BINARY_OP_INPLACE_ADD:
lhs->val += rhs_val;
return lhs;
lhs->val += rhs_val; return lhs;
case RT_BINARY_OP_INPLACE_SUBTRACT:
lhs->val -= rhs_val;
return lhs;
lhs->val -= rhs_val; return lhs;
case RT_BINARY_OP_INPLACE_MULTIPLY:
lhs->val *= rhs_val; return lhs;
case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE:
lhs->val /= rhs_val; return lhs;
case RT_BINARY_OP_INPLACE_MODULO:
lhs->val %= rhs_val; return lhs;
case RT_BINARY_OP_AND:
return mp_obj_new_int_from_ll(lhs->val & rhs_val);
@ -65,11 +86,23 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
case RT_BINARY_OP_XOR:
return mp_obj_new_int_from_ll(lhs->val ^ rhs_val);
case RT_BINARY_OP_INPLACE_AND:
lhs->val &= rhs_val; return lhs;
case RT_BINARY_OP_INPLACE_OR:
lhs->val |= rhs_val; return lhs;
case RT_BINARY_OP_INPLACE_XOR:
lhs->val ^= rhs_val; return lhs;
case RT_BINARY_OP_LSHIFT:
return mp_obj_new_int_from_ll(lhs->val << (int)rhs_val);
case RT_BINARY_OP_RSHIFT:
return mp_obj_new_int_from_ll(lhs->val >> (int)rhs_val);
case RT_BINARY_OP_INPLACE_LSHIFT:
lhs->val <<= (int)rhs_val; return lhs;
case RT_BINARY_OP_INPLACE_RSHIFT:
lhs->val >>= (int)rhs_val; return lhs;
case RT_COMPARE_OP_LESS:
return MP_BOOL(lhs->val < rhs_val);
case RT_COMPARE_OP_MORE:

12
py/objlist.c
Wyświetl plik

@ -23,6 +23,9 @@ static mp_obj_t mp_obj_new_list_iterator(mp_obj_list_t *list, int cur);
static mp_obj_list_t *list_new(uint n);
static mp_obj_t list_extend(mp_obj_t self_in, mp_obj_t arg_in);
// TODO: Move to mpconfig.h
#define LIST_MIN_ALLOC 4
/******************************************************************************/
/* list */
@ -189,6 +192,7 @@ mp_obj_t mp_obj_list_append(mp_obj_t self_in, mp_obj_t arg) {
mp_obj_list_t *self = self_in;
if (self->len >= self->alloc) {
self->items = m_renew(mp_obj_t, self->items, self->alloc, self->alloc * 2);
assert(self->items);
self->alloc *= 2;
}
self->items[self->len++] = arg;
@ -223,7 +227,7 @@ static mp_obj_t list_pop(uint n_args, const mp_obj_t *args) {
mp_obj_t ret = self->items[index];
self->len -= 1;
memcpy(self->items + index, self->items + index + 1, (self->len - index) * sizeof(mp_obj_t));
if (self->alloc > 2 * self->len) {
if (self->alloc > LIST_MIN_ALLOC && self->alloc > 2 * self->len) {
self->items = m_renew(mp_obj_t, self->items, self->alloc, self->alloc/2);
self->alloc /= 2;
}
@ -275,8 +279,8 @@ static mp_obj_t list_clear(mp_obj_t self_in) {
assert(MP_OBJ_IS_TYPE(self_in, &list_type));
mp_obj_list_t *self = self_in;
self->len = 0;
self->items = m_renew(mp_obj_t, self->items, self->alloc, 4);
self->alloc = 4;
self->items = m_renew(mp_obj_t, self->items, self->alloc, LIST_MIN_ALLOC);
self->alloc = LIST_MIN_ALLOC;
return mp_const_none;
}
@ -412,7 +416,7 @@ const mp_obj_type_t list_type = {
static mp_obj_list_t *list_new(uint n) {
mp_obj_list_t *o = m_new_obj(mp_obj_list_t);
o->base.type = &list_type;
o->alloc = n < 4 ? 4 : n;
o->alloc = n < LIST_MIN_ALLOC ? LIST_MIN_ALLOC : n;
o->len = n;
o->items = m_new(mp_obj_t, o->alloc);
return o;

22
tests/basics/generator_send.py
Wyświetl plik

@ -13,3 +13,25 @@ except TypeError:
print(g.send(None))
print(g.send(100))
print(g.send(200))
def f2():
print("entering")
for i in range(3):
print(i)
yield
print("returning 1")
print("returning 2")
g = f2()
g.send(None)
g.send(1)
g.send(1)
try:
g.send(1)
except StopIteration:
print("caught")
try:
g.send(1)
except StopIteration:
print("caught")

39
tests/basics/int-long.py 100644
Wyświetl plik

@ -0,0 +1,39 @@
# This tests long ints for 32-bit machine
a = 0x1ffffffff
b = 0x100000000
print(a)
print(b)
print(a + b)
print(a - b)
print(b - a)
# overflows long long implementation
#print(a * b)
print(a // b)
print(a % b)
print(a & b)
print(a | b)
print(a ^ b)
print(a << 3)
print(a >> 1)
a += b
print(a)
a -= 123456
print(a)
a *= 257
print(a)
a //= 257
print(a)
a %= b
print(a)
a ^= b
print(a)
a |= b
print(a)
a &= b
print(a)
a <<= 5
print(a)
a >>= 1
print(a)