py: Make False and True act like 0 and 1 for integer arithmetic.

py/objbool.c

@@ -1,3 +1,4 @@
+#include <stdlib.h>
 
 #include "nlr.h"
 #include "misc.h"
@@ -43,12 +44,21 @@ STATIC mp_obj_t bool_unary_op(int op, mp_obj_t o_in) {
     }
 }
 
+STATIC mp_obj_t bool_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
+    if (MP_BINARY_OP_OR <= op && op <= MP_BINARY_OP_NOT_EQUAL) {
+        return mp_binary_op(op, MP_OBJ_NEW_SMALL_INT((machine_int_t)mp_obj_is_true(lhs_in)), rhs_in);
+    }
+    // operation not supported
+    return MP_OBJ_NULL;
+}
+
 const mp_obj_type_t mp_type_bool = {
     { &mp_type_type },
     .name = MP_QSTR_bool,
     .print = bool_print,
     .make_new = bool_make_new,
     .unary_op = bool_unary_op,
+    .binary_op = bool_binary_op,
 };
 
 const mp_obj_bool_t mp_const_false_obj = {{&mp_type_bool}, false};

py/objint.c

@@ -17,9 +17,8 @@
 #include <math.h>
 #endif
 
-// This dispatcher function is expected to be independent of the implementation
+// This dispatcher function is expected to be independent of the implementation of long int
-// of long int
+STATIC mp_obj_t mp_obj_int_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
-STATIC mp_obj_t int_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
     // TODO check n_kw == 0
 
     switch (n_args) {
@@ -56,26 +55,20 @@ STATIC mp_obj_t int_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_
 
 #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_NONE
 
-void int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
+void mp_obj_int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
     if (MP_OBJ_IS_SMALL_INT(self_in)) {
         print(env, INT_FMT, MP_OBJ_SMALL_INT_VALUE(self_in));
     }
 }
 
 // This is called for operations on SMALL_INT that are not handled by mp_unary_op
-mp_obj_t int_unary_op(int op, mp_obj_t o_in) {
+mp_obj_t mp_obj_int_unary_op(int op, mp_obj_t o_in) {
     return MP_OBJ_NULL;
 }
 
 // This is called for operations on SMALL_INT that are not handled by mp_binary_op
-mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
+mp_obj_t mp_obj_int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
-    if (op == MP_BINARY_OP_MULTIPLY) {
+    return mp_obj_int_binary_op_extra_cases(op, lhs_in, rhs_in);
-        if (MP_OBJ_IS_STR(rhs_in) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_list)) {
-            // multiply is commutative for these types, so delegate to them
-            return mp_binary_op(op, rhs_in, lhs_in);
-        }
-    }
-    return MP_OBJ_NULL;
 }
 
 // This is called only with strings whose value doesn't fit in SMALL_INT
@@ -124,11 +117,29 @@ mp_float_t mp_obj_int_as_float(mp_obj_t self_in) {
 
 #endif // MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_NONE
 
+// This dispatcher function is expected to be independent of the implementation of long int
+// It handles the extra cases for integer-like arithmetic
+mp_obj_t mp_obj_int_binary_op_extra_cases(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
+    if (rhs_in == mp_const_false) {
+        // false acts as 0
+        return mp_binary_op(op, lhs_in, MP_OBJ_NEW_SMALL_INT(0));
+    } else if (rhs_in == mp_const_true) {
+        // true acts as 0
+        return mp_binary_op(op, lhs_in, MP_OBJ_NEW_SMALL_INT(1));
+    } else if (op == MP_BINARY_OP_MULTIPLY) {
+        if (MP_OBJ_IS_STR(rhs_in) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_list)) {
+            // multiply is commutative for these types, so delegate to them
+            return mp_binary_op(op, rhs_in, lhs_in);
+        }
+    }
+    return MP_OBJ_NULL;
+}
+
 const mp_obj_type_t mp_type_int = {
     { &mp_type_type },
     .name = MP_QSTR_int,
-    .print = int_print,
+    .print = mp_obj_int_print,
-    .make_new = int_make_new,
+    .make_new = mp_obj_int_make_new,
-    .unary_op = int_unary_op,
+    .unary_op = mp_obj_int_unary_op,
-    .binary_op = int_binary_op,
+    .binary_op = mp_obj_int_binary_op,
 };

py/objint.h

@@ -7,6 +7,7 @@ typedef struct _mp_obj_int_t {
 #endif
 } 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);
+void mp_obj_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 mp_obj_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);
+mp_obj_t mp_obj_int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in);
+mp_obj_t mp_obj_int_binary_op_extra_cases(int op, mp_obj_t lhs_in, mp_obj_t rhs_in);

py/objint_longlong.c

@@ -21,7 +21,7 @@
 #define SUFFIX ""
 #endif
 
-void int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
+void mp_obj_int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
     if (MP_OBJ_IS_SMALL_INT(self_in)) {
         print(env, INT_FMT, MP_OBJ_SMALL_INT_VALUE(self_in));
     } else {
@@ -30,7 +30,7 @@ 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_t mp_obj_int_unary_op(int op, mp_obj_t o_in) {
     mp_obj_int_t *o = o_in;
     switch (op) {
         case MP_UNARY_OP_BOOL: return MP_BOOL(o->val != 0);
@@ -41,7 +41,7 @@ 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) {
+mp_obj_t mp_obj_int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
     long long lhs_val;
     long long rhs_val;
 
@@ -58,14 +58,8 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
     } else if (MP_OBJ_IS_TYPE(rhs_in, &mp_type_int)) {
         rhs_val = ((mp_obj_int_t*)rhs_in)->val;
     } else {
-        if (op == MP_BINARY_OP_MULTIPLY) {
+        // delegate to generic function to check for extra cases
-            if (MP_OBJ_IS_STR(rhs_in) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_list)) {
+        return mp_obj_int_binary_op_extra_cases(op, lhs_in, rhs_in);
-                // multiply is commutative for these types, so delegate to them
-                return mp_binary_op(op, rhs_in, lhs_in);
-            }
-        }
-        // unsupported operation/type
-        return MP_OBJ_NULL;
     }
 
     switch (op) {

py/objint_mpz.c

@@ -22,7 +22,7 @@ STATIC mp_obj_int_t *mp_obj_int_new_mpz(void) {
     return o;
 }
 
-void int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
+void mp_obj_int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
     if (MP_OBJ_IS_SMALL_INT(self_in)) {
         print(env, INT_FMT, MP_OBJ_SMALL_INT_VALUE(self_in));
     } else {
@@ -34,7 +34,7 @@ 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_t mp_obj_int_unary_op(int op, mp_obj_t o_in) {
     mp_obj_int_t *o = o_in;
     switch (op) {
         case MP_UNARY_OP_BOOL: return MP_BOOL(!mpz_is_zero(&o->mpz));
@@ -45,7 +45,7 @@ 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) {
+mp_obj_t mp_obj_int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
     const mpz_t *zlhs;
     const mpz_t *zrhs;
     mpz_t z_int;
@@ -75,14 +75,8 @@ mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
         return mp_obj_complex_binary_op(op, mpz_as_float(zlhs), 0, rhs_in);
 #endif
     } else {
-        if (op == MP_BINARY_OP_MULTIPLY) {
+        // delegate to generic function to check for extra cases
-            if (MP_OBJ_IS_STR(rhs_in) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(rhs_in, &mp_type_list)) {
+        return mp_obj_int_binary_op_extra_cases(op, lhs_in, rhs_in);
-                // multiply is commutative for these types, so delegate to them
-                return mp_binary_op(op, rhs_in, lhs_in);
-            }
-        }
-        // unsupported operation/type
-        return MP_OBJ_NULL;
     }
 
     if (0) {