mirror of
https://github.com/python/cpython.git
synced 2025-08-03 16:39:00 +00:00
Added shift and mask ops.
This commit is contained in:
Guido van Rossum
parent
7a6dfa7d79
commit
7928cd7636
5 changed files with 426 additions and 45 deletions
170
Python/ceval.c
170
Python/ceval.c
|
|
@ -51,6 +51,12 @@ static object *rem();
|
|||
static object *neg();
|
||||
static object *pos();
|
||||
static object *not();
|
||||
static object *invert();
|
||||
static object *lshift();
|
||||
static object *rshift();
|
||||
static object *and();
|
||||
static object *xor();
|
||||
static object *or();
|
||||
static object *call_builtin();
|
||||
static object *call_function();
|
||||
static object *apply_subscript();
|
||||
|
|
@ -273,6 +279,13 @@ eval_code(co, globals, locals, arg)
|
|||
DECREF(v);
|
||||
PUSH(x);
|
||||
break;
|
||||
|
||||
case UNARY_INVERT:
|
||||
v = POP();
|
||||
x = invert(v);
|
||||
DECREF(v);
|
||||
PUSH(x);
|
||||
break;
|
||||
|
||||
case BINARY_MULTIPLY:
|
||||
w = POP();
|
||||
|
|
@ -340,6 +353,51 @@ eval_code(co, globals, locals, arg)
|
|||
PUSH(x);
|
||||
break;
|
||||
|
||||
case BINARY_LSHIFT:
|
||||
w = POP();
|
||||
v = POP();
|
||||
x = lshift(v, w);
|
||||
DECREF(v);
|
||||
DECREF(w);
|
||||
PUSH(x);
|
||||
break;
|
||||
|
||||
case BINARY_RSHIFT:
|
||||
w = POP();
|
||||
v = POP();
|
||||
x = rshift(v, w);
|
||||
DECREF(v);
|
||||
DECREF(w);
|
||||
PUSH(x);
|
||||
break;
|
||||
|
||||
case BINARY_AND:
|
||||
w = POP();
|
||||
v = POP();
|
||||
x = and(v, w);
|
||||
DECREF(v);
|
||||
DECREF(w);
|
||||
PUSH(x);
|
||||
break;
|
||||
|
||||
case BINARY_XOR:
|
||||
w = POP();
|
||||
v = POP();
|
||||
x = xor(v, w);
|
||||
DECREF(v);
|
||||
DECREF(w);
|
||||
PUSH(x);
|
||||
break;
|
||||
|
||||
case BINARY_OR:
|
||||
w = POP();
|
||||
v = POP();
|
||||
x = or(v, w);
|
||||
DECREF(v);
|
||||
DECREF(w);
|
||||
PUSH(x);
|
||||
break;
|
||||
|
||||
case SLICE+0:
|
||||
case SLICE+1:
|
||||
case SLICE+2:
|
||||
|
|
@ -1001,6 +1059,106 @@ testbool(v)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static object *
|
||||
or(v, w)
|
||||
object *v, *w;
|
||||
{
|
||||
if (v->ob_type->tp_as_number != NULL) {
|
||||
object *x;
|
||||
object * (*f) FPROTO((object *, object *));
|
||||
if (coerce(&v, &w) != 0)
|
||||
return NULL;
|
||||
if ((f = v->ob_type->tp_as_number->nb_or) != NULL)
|
||||
x = (*f)(v, w);
|
||||
DECREF(v);
|
||||
DECREF(w);
|
||||
if (f != NULL)
|
||||
return x;
|
||||
}
|
||||
err_setstr(TypeError, "bad operand type(s) for |");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static object *
|
||||
xor(v, w)
|
||||
object *v, *w;
|
||||
{
|
||||
if (v->ob_type->tp_as_number != NULL) {
|
||||
object *x;
|
||||
object * (*f) FPROTO((object *, object *));
|
||||
if (coerce(&v, &w) != 0)
|
||||
return NULL;
|
||||
if ((f = v->ob_type->tp_as_number->nb_xor) != NULL)
|
||||
x = (*f)(v, w);
|
||||
DECREF(v);
|
||||
DECREF(w);
|
||||
if (f != NULL)
|
||||
return x;
|
||||
}
|
||||
err_setstr(TypeError, "bad operand type(s) for ^");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static object *
|
||||
and(v, w)
|
||||
object *v, *w;
|
||||
{
|
||||
if (v->ob_type->tp_as_number != NULL) {
|
||||
object *x;
|
||||
object * (*f) FPROTO((object *, object *));
|
||||
if (coerce(&v, &w) != 0)
|
||||
return NULL;
|
||||
if ((f = v->ob_type->tp_as_number->nb_and) != NULL)
|
||||
x = (*f)(v, w);
|
||||
DECREF(v);
|
||||
DECREF(w);
|
||||
if (f != NULL)
|
||||
return x;
|
||||
}
|
||||
err_setstr(TypeError, "bad operand type(s) for &");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static object *
|
||||
lshift(v, w)
|
||||
object *v, *w;
|
||||
{
|
||||
if (v->ob_type->tp_as_number != NULL) {
|
||||
object *x;
|
||||
object * (*f) FPROTO((object *, object *));
|
||||
if (coerce(&v, &w) != 0)
|
||||
return NULL;
|
||||
if ((f = v->ob_type->tp_as_number->nb_lshift) != NULL)
|
||||
x = (*f)(v, w);
|
||||
DECREF(v);
|
||||
DECREF(w);
|
||||
if (f != NULL)
|
||||
return x;
|
||||
}
|
||||
err_setstr(TypeError, "bad operand type(s) for <<");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static object *
|
||||
rshift(v, w)
|
||||
object *v, *w;
|
||||
{
|
||||
if (v->ob_type->tp_as_number != NULL) {
|
||||
object *x;
|
||||
object * (*f) FPROTO((object *, object *));
|
||||
if (coerce(&v, &w) != 0)
|
||||
return NULL;
|
||||
if ((f = v->ob_type->tp_as_number->nb_rshift) != NULL)
|
||||
x = (*f)(v, w);
|
||||
DECREF(v);
|
||||
DECREF(w);
|
||||
if (f != NULL)
|
||||
return x;
|
||||
}
|
||||
err_setstr(TypeError, "bad operand type(s) for >>");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static object *
|
||||
add(v, w)
|
||||
object *v, *w;
|
||||
|
|
@ -1127,6 +1285,18 @@ pos(v)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static object *
|
||||
invert(v)
|
||||
object *v;
|
||||
{
|
||||
object * (*f) FPROTO((object *, object *));
|
||||
if (v->ob_type->tp_as_number != NULL &&
|
||||
(f = v->ob_type->tp_as_number->nb_invert) != NULL)
|
||||
return (*f)(v);
|
||||
err_setstr(TypeError, "bad operand type(s) for unary ~");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static object *
|
||||
not(v)
|
||||
object *v;
|
||||
|
|
|
|||
175
Python/compile.c
175
Python/compile.c
|
|
@ -689,6 +689,10 @@ com_factor(c, n)
|
|||
com_factor(c, CHILD(n, 1));
|
||||
com_addbyte(c, UNARY_NEGATIVE);
|
||||
}
|
||||
else if (TYPE(CHILD(n, 0)) == TILDE) {
|
||||
com_factor(c, CHILD(n, 1));
|
||||
com_addbyte(c, UNARY_INVERT);
|
||||
}
|
||||
else {
|
||||
com_atom(c, CHILD(n, 0));
|
||||
for (i = 1; i < NCH(n); i++)
|
||||
|
|
@ -719,7 +723,111 @@ com_term(c, n)
|
|||
break;
|
||||
default:
|
||||
err_setstr(SystemError,
|
||||
"com_term: term operator not *, / or %");
|
||||
"com_term: operator not *, / or %");
|
||||
c->c_errors++;
|
||||
op = 255;
|
||||
}
|
||||
com_addbyte(c, op);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
com_arith_expr(c, n)
|
||||
struct compiling *c;
|
||||
node *n;
|
||||
{
|
||||
int i;
|
||||
int op;
|
||||
REQ(n, arith_expr);
|
||||
com_term(c, CHILD(n, 0));
|
||||
for (i = 2; i < NCH(n); i += 2) {
|
||||
com_term(c, CHILD(n, i));
|
||||
switch (TYPE(CHILD(n, i-1))) {
|
||||
case PLUS:
|
||||
op = BINARY_ADD;
|
||||
break;
|
||||
case MINUS:
|
||||
op = BINARY_SUBTRACT;
|
||||
break;
|
||||
default:
|
||||
err_setstr(SystemError,
|
||||
"com_arith_expr: operator not + or -");
|
||||
c->c_errors++;
|
||||
op = 255;
|
||||
}
|
||||
com_addbyte(c, op);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
com_shift_expr(c, n)
|
||||
struct compiling *c;
|
||||
node *n;
|
||||
{
|
||||
int i;
|
||||
int op;
|
||||
REQ(n, shift_expr);
|
||||
com_arith_expr(c, CHILD(n, 0));
|
||||
for (i = 2; i < NCH(n); i += 2) {
|
||||
com_arith_expr(c, CHILD(n, i));
|
||||
switch (TYPE(CHILD(n, i-1))) {
|
||||
case LEFTSHIFT:
|
||||
op = BINARY_LSHIFT;
|
||||
break;
|
||||
case RIGHTSHIFT:
|
||||
op = BINARY_RSHIFT;
|
||||
break;
|
||||
default:
|
||||
err_setstr(SystemError,
|
||||
"com_shift_expr: operator not << or >>");
|
||||
c->c_errors++;
|
||||
op = 255;
|
||||
}
|
||||
com_addbyte(c, op);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
com_and_expr(c, n)
|
||||
struct compiling *c;
|
||||
node *n;
|
||||
{
|
||||
int i;
|
||||
int op;
|
||||
REQ(n, and_expr);
|
||||
com_shift_expr(c, CHILD(n, 0));
|
||||
for (i = 2; i < NCH(n); i += 2) {
|
||||
com_shift_expr(c, CHILD(n, i));
|
||||
if (TYPE(CHILD(n, i-1)) == AMPER) {
|
||||
op = BINARY_AND;
|
||||
}
|
||||
else {
|
||||
err_setstr(SystemError,
|
||||
"com_and_expr: operator not &");
|
||||
c->c_errors++;
|
||||
op = 255;
|
||||
}
|
||||
com_addbyte(c, op);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
com_xor_expr(c, n)
|
||||
struct compiling *c;
|
||||
node *n;
|
||||
{
|
||||
int i;
|
||||
int op;
|
||||
REQ(n, xor_expr);
|
||||
com_and_expr(c, CHILD(n, 0));
|
||||
for (i = 2; i < NCH(n); i += 2) {
|
||||
com_and_expr(c, CHILD(n, i));
|
||||
if (TYPE(CHILD(n, i-1)) == CIRCUMFLEX) {
|
||||
op = BINARY_XOR;
|
||||
}
|
||||
else {
|
||||
err_setstr(SystemError,
|
||||
"com_xor_expr: operator not ^");
|
||||
c->c_errors++;
|
||||
op = 255;
|
||||
}
|
||||
|
|
@ -735,19 +843,15 @@ com_expr(c, n)
|
|||
int i;
|
||||
int op;
|
||||
REQ(n, expr);
|
||||
com_term(c, CHILD(n, 0));
|
||||
com_xor_expr(c, CHILD(n, 0));
|
||||
for (i = 2; i < NCH(n); i += 2) {
|
||||
com_term(c, CHILD(n, i));
|
||||
switch (TYPE(CHILD(n, i-1))) {
|
||||
case PLUS:
|
||||
op = BINARY_ADD;
|
||||
break;
|
||||
case MINUS:
|
||||
op = BINARY_SUBTRACT;
|
||||
break;
|
||||
default:
|
||||
com_xor_expr(c, CHILD(n, i));
|
||||
if (TYPE(CHILD(n, i-1)) == VBAR) {
|
||||
op = BINARY_OR;
|
||||
}
|
||||
else {
|
||||
err_setstr(SystemError,
|
||||
"com_expr: expr operator not + or -");
|
||||
"com_expr: expr operator not |");
|
||||
c->c_errors++;
|
||||
op = 255;
|
||||
}
|
||||
|
|
@ -1065,35 +1169,12 @@ com_assign(c, n, assigning)
|
|||
case test:
|
||||
case and_test:
|
||||
case not_test:
|
||||
if (NCH(n) > 1) {
|
||||
err_setstr(TypeError,
|
||||
"can't assign to operator");
|
||||
c->c_errors++;
|
||||
return;
|
||||
}
|
||||
n = CHILD(n, 0);
|
||||
break;
|
||||
|
||||
case comparison:
|
||||
if (NCH(n) > 1) {
|
||||
err_setstr(TypeError,
|
||||
"can't assign to operator");
|
||||
c->c_errors++;
|
||||
return;
|
||||
}
|
||||
n = CHILD(n, 0);
|
||||
break;
|
||||
|
||||
case expr:
|
||||
if (NCH(n) > 1) {
|
||||
err_setstr(TypeError,
|
||||
"can't assign to operator");
|
||||
c->c_errors++;
|
||||
return;
|
||||
}
|
||||
n = CHILD(n, 0);
|
||||
break;
|
||||
|
||||
case xor_expr:
|
||||
case and_expr:
|
||||
case shift_expr:
|
||||
case arith_expr:
|
||||
case term:
|
||||
if (NCH(n) > 1) {
|
||||
err_setstr(TypeError,
|
||||
|
|
@ -1104,8 +1185,8 @@ com_assign(c, n, assigning)
|
|||
n = CHILD(n, 0);
|
||||
break;
|
||||
|
||||
case factor: /* ('+'|'-') factor | atom trailer* */
|
||||
if (TYPE(CHILD(n, 0)) != atom) { /* '+' | '-' */
|
||||
case factor: /* ('+'|'-'|'~') factor | atom trailer* */
|
||||
if (TYPE(CHILD(n, 0)) != atom) { /* '+'|'-'|'~' */
|
||||
err_setstr(TypeError,
|
||||
"can't assign to operator");
|
||||
c->c_errors++;
|
||||
|
|
@ -1728,6 +1809,18 @@ com_node(c, n)
|
|||
case expr:
|
||||
com_expr(c, n);
|
||||
break;
|
||||
case xor_expr:
|
||||
com_xor_expr(c, n);
|
||||
break;
|
||||
case and_expr:
|
||||
com_and_expr(c, n);
|
||||
break;
|
||||
case shift_expr:
|
||||
com_shift_expr(c, n);
|
||||
break;
|
||||
case arith_expr:
|
||||
com_arith_expr(c, n);
|
||||
break;
|
||||
case term:
|
||||
com_term(c, n);
|
||||
break;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue