py: Separate MICROPY_PY_BUILTINS_COMPLEX from MICROPY_PY_BUILTINS_FLOAT.

pfalcon · pfalcon · commit 3b6f7b95eb48 · 2014-06-20T18:00:23.000+03:00
One thing is wanting to do 1 / 2 and get something else but 0, and quite
another - doing rocket science ;-).
diff --git a/py/builtin.c b/py/builtin.c
@@ -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);
diff --git a/py/builtintables.c b/py/builtintables.c
@@ -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 },
diff --git a/py/mpconfig.h b/py/mpconfig.h
@@ -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
diff --git a/py/obj.c b/py/obj.c
@@ -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)) {
diff --git a/py/objcomplex.c b/py/objcomplex.c
@@ -36,7 +36,7 @@
 #include "runtime0.h"
 #include "runtime.h"
 
-#if MICROPY_PY_BUILTINS_FLOAT
+#if MICROPY_PY_BUILTINS_COMPLEX
 
 #include <math.h>
 
diff --git a/py/objfloat.c b/py/objfloat.c
@@ -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);
     }
 }
diff --git a/py/objint_mpz.c b/py/objint_mpz.c
@@ -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
diff --git a/py/parsenum.c b/py/parsenum.c
@@ -35,6 +35,7 @@
 #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);
     }
diff --git a/py/runtime.c b/py/runtime.c
@@ -426,13 +426,15 @@ 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) {
                 goto unsupported_op;
             } else {
                 return res;
             }
+#endif
 #endif
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -274,6 +274,7 @@ mp_float_t mp_obj_get_float(mp_obj_t arg) {`
`274`	`274`	`}`
`275`	`275`	`}`
`276`	`276`
	`277`	`+#if MICROPY_PY_BUILTINS_COMPLEX`
`277`	`278`	`void mp_obj_get_complex(mp_obj_t arg, mp_float_t real, mp_float_t imag) {`
`278`	`279`	`if (arg == mp_const_false) {`
`279`	`280`	`*real = 0;`
`@@ -297,6 +298,7 @@ void mp_obj_get_complex(mp_obj_t arg, mp_float_t real, mp_float_t imag) {`
`297`	`298`	`}`
`298`	`299`	`}`
`299`	`300`	`#endif`
	`301`	`+#endif`
`300`	`302`
`301`	`303`	`void mp_obj_get_array(mp_obj_t o, uint len, mp_obj_t *items) {`
`302`	`304`	`if (MP_OBJ_IS_TYPE(o, &mp_type_tuple)) {`
Original file line number	Diff line number	Diff line change
`@@ -102,9 +102,12 @@ STATIC mp_obj_t float_unary_op(int op, mp_obj_t o_in) {`
`102`	`102`
`103`	`103`	`STATIC mp_obj_t float_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {`
`104`	`104`	`mp_obj_float_t *lhs = lhs_in;`
	`105`	`+#if MICROPY_PY_BUILTINS_COMPLEX`
`105`	`106`	`if (MP_OBJ_IS_TYPE(rhs_in, &mp_type_complex)) {`
`106`	`107`	`return mp_obj_complex_binary_op(op, lhs->value, 0, rhs_in);`
`107`		`- } else {`
	`108`	`+ } else`
	`109`	`+#endif`
	`110`	`+ {`
`108`	`111`	`return mp_obj_float_binary_op(op, lhs->value, rhs_in);`
`109`	`112`	`}`
`110`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -426,13 +426,15 @@ mp_obj_t mp_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {`
`426`	`426`	`} else {`
`427`	`427`	`return res;`
`428`	`428`	`}`
	`429`	`+#if MICROPY_PY_BUILTINS_COMPLEX`
`429`	`430`	`} else if (MP_OBJ_IS_TYPE(rhs, &mp_type_complex)) {`
`430`	`431`	`mp_obj_t res = mp_obj_complex_binary_op(op, lhs_val, 0, rhs);`
`431`	`432`	`if (res == MP_OBJ_NULL) {`
`432`	`433`	`goto unsupported_op;`
`433`	`434`	`} else {`
`434`	`435`	`return res;`
`435`	`436`	`}`
	`437`	`+#endif`
`436`	`438`	`#endif`
`437`	`439`	`}`
`438`	`440`	`}`