py: Use mp_arg_check_num in more places.

dpgeorge · dpgeorge · commit ee7a880d6e66 · 2014-05-11T18:37:21.000+01:00
Updated functions now do proper checking that n_kw==0, and are simpler
because they don't have to explicitly raise an exception.  Down side is
that the error messages no longer include the function name, but that's
acceptable.

Saves order 300 text bytes on x64 and ARM.
diff --git a/py/objbool.c b/py/objbool.c
@@ -49,12 +49,14 @@ STATIC void bool_print(void (*print)(void *env, const char *fmt, ...), void *env
 }
 
 STATIC mp_obj_t bool_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
-    // TODO check n_kw == 0
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
 
     switch (n_args) {
-        case 0: return mp_const_false;
-        case 1: if (mp_obj_is_true(args[0])) { return mp_const_true; } else { return mp_const_false; }
-        default: nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "bool takes at most 1 argument, %d given", n_args));
+        case 0:
+            return mp_const_false;
+        case 1:
+        default: // must be 0 or 1
+            if (mp_obj_is_true(args[0])) { return mp_const_true; } else { return mp_const_false; }
     }
 }
 
diff --git a/py/objcomplex.c b/py/objcomplex.c
@@ -34,6 +34,7 @@
 #include "obj.h"
 #include "parsenum.h"
 #include "runtime0.h"
+#include "runtime.h"
 
 #if MICROPY_ENABLE_FLOAT
 
@@ -74,7 +75,7 @@ STATIC void complex_print(void (*print)(void *env, const char *fmt, ...), void *
 }
 
 STATIC mp_obj_t complex_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
-    // TODO check n_kw == 0
+    mp_arg_check_num(n_args, n_kw, 0, 2, false);
 
     switch (n_args) {
         case 0:
@@ -94,7 +95,8 @@ STATIC mp_obj_t complex_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const
                 return mp_obj_new_complex(mp_obj_get_float(args[0]), 0);
             }
 
-        case 2: {
+        case 2:
+        default: {
             mp_float_t real, imag;
             if (MP_OBJ_IS_TYPE(args[0], &mp_type_complex)) {
                 mp_obj_complex_get(args[0], &real, &imag);
@@ -112,9 +114,6 @@ STATIC mp_obj_t complex_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const
             }
             return mp_obj_new_complex(real, imag);
         }
-
-        default:
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "complex takes at most 2 arguments, %d given", n_args));
     }
 }
 
diff --git a/py/objfloat.c b/py/objfloat.c
@@ -37,6 +37,7 @@
 #include "obj.h"
 #include "parsenum.h"
 #include "runtime0.h"
+#include "runtime.h"
 
 #if MICROPY_ENABLE_FLOAT
 
@@ -66,13 +67,14 @@ STATIC void float_print(void (*print)(void *env, const char *fmt, ...), void *en
 }
 
 STATIC mp_obj_t float_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
-    // TODO check n_kw == 0
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
 
     switch (n_args) {
         case 0:
             return mp_obj_new_float(0);
 
         case 1:
+        default:
             if (MP_OBJ_IS_STR(args[0])) {
                 // a string, parse it
                 uint l;
@@ -85,9 +87,6 @@ STATIC mp_obj_t float_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const m
                 // something else, try to cast it to a float
                 return mp_obj_new_float(mp_obj_get_float(args[0]));
             }
-
-        default:
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "float takes at most 1 argument, %d given", n_args));
     }
 }
 
diff --git a/py/objint.c b/py/objint.c
@@ -46,7 +46,7 @@
 
 // This dispatcher function is expected to be independent of the implementation 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) {
-    // TODO check n_kw == 0
+    mp_arg_check_num(n_args, n_kw, 0, 2, false);
 
     switch (n_args) {
         case 0:
@@ -67,16 +67,13 @@ STATIC mp_obj_t mp_obj_int_make_new(mp_obj_t type_in, uint n_args, uint n_kw, co
             }
 
         case 2:
-        {
+        default: {
             // should be a string, parse it
             // TODO proper error checking of argument types
             uint l;
             const char *s = mp_obj_str_get_data(args[0], &l);
             return mp_parse_num_integer(s, l, mp_obj_get_int(args[1]));
         }
-
-        default:
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "int takes at most 2 arguments, %d given", n_args));
     }
 }
 
diff --git a/py/objlist.c b/py/objlist.c
@@ -69,23 +69,20 @@ STATIC mp_obj_t list_extend_from_iter(mp_obj_t list, mp_obj_t iterable) {
 }
 
 STATIC mp_obj_t list_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
-    // TODO check n_kw == 0
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
 
     switch (n_args) {
         case 0:
             // return a new, empty list
             return mp_obj_new_list(0, NULL);
 
         case 1:
-        {
+        default: {
             // make list from iterable
             // TODO: optimize list/tuple
             mp_obj_t list = mp_obj_new_list(0, NULL);
             return list_extend_from_iter(list, args[0]);
         }
-
-        default:
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "list takes at most 1 argument, %d given", n_args));
     }
 }
 
diff --git a/py/objproperty.c b/py/objproperty.c
@@ -42,13 +42,10 @@ typedef struct _mp_obj_property_t {
 } mp_obj_property_t;
 
 STATIC mp_obj_t property_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
-    // TODO check n_kw == 0
+    mp_arg_check_num(n_args, n_kw, 0, 4, false);
 
     mp_obj_property_t *o = m_new_obj(mp_obj_property_t);
     o->base.type = &mp_type_property;
-    if (n_args >= 5) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "property takes at most 4 arguments"));
-    }
     if (n_args >= 4) {
         // doc ignored
     }
diff --git a/py/objtuple.c b/py/objtuple.c
@@ -57,14 +57,15 @@ void mp_obj_tuple_print(void (*print)(void *env, const char *fmt, ...), void *en
 }
 
 STATIC mp_obj_t mp_obj_tuple_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
-    // TODO check n_kw == 0
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
 
     switch (n_args) {
         case 0:
             // return a empty tuple
             return mp_const_empty_tuple;
 
-        case 1: {
+        case 1:
+        default: {
             // 1 argument, an iterable from which we make a new tuple
             if (MP_OBJ_IS_TYPE(args[0], &mp_type_tuple)) {
                 return args[0];
@@ -91,9 +92,6 @@ STATIC mp_obj_t mp_obj_tuple_make_new(mp_obj_t type_in, uint n_args, uint n_kw,
 
             return tuple;
         }
-
-        default:
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "tuple takes at most 1 argument, %d given", n_args));
     }
 }
 
diff --git a/py/objtype.c b/py/objtype.c
@@ -540,7 +540,7 @@ STATIC void type_print(void (*print)(void *env, const char *fmt, ...), void *env
 }
 
 STATIC mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
-    // TODO check n_kw == 0
+    mp_arg_check_num(n_args, n_kw, 1, 3, false);
 
     switch (n_args) {
         case 1:
diff --git a/py/objzip.c b/py/objzip.c
@@ -40,7 +40,7 @@ typedef struct _mp_obj_zip_t {
 } mp_obj_zip_t;
 
 STATIC mp_obj_t zip_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
-    // TODO check n_kw == 0
+    mp_arg_check_num(n_args, n_kw, 0, MP_OBJ_FUN_ARGS_MAX, false);
 
     mp_obj_zip_t *o = m_new_obj_var(mp_obj_zip_t, mp_obj_t, n_args);
     o->base.type = &mp_type_zip;

Original file line number	Diff line number	Diff line change
`@@ -49,12 +49,14 @@ STATIC void bool_print(void (print)(void env, const char fmt, ...), void env`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`STATIC mp_obj_t bool_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {`
`52`		`- // TODO check n_kw == 0`
	`52`	`+ mp_arg_check_num(n_args, n_kw, 0, 1, false);`
`53`	`53`
`54`	`54`	`switch (n_args) {`
`55`		`- case 0: return mp_const_false;`
`56`		`- case 1: if (mp_obj_is_true(args[0])) { return mp_const_true; } else { return mp_const_false; }`
`57`		`- default: nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "bool takes at most 1 argument, %d given", n_args));`
	`55`	`+ case 0:`
	`56`	`+ return mp_const_false;`
	`57`	`+ case 1:`
	`58`	`+ default: // must be 0 or 1`
	`59`	`+ if (mp_obj_is_true(args[0])) { return mp_const_true; } else { return mp_const_false; }`
`58`	`60`	`}`
`59`	`61`	`}`
`60`	`62`
Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,7 @@`
`34`	`34`	`#include "obj.h"`
`35`	`35`	`#include "parsenum.h"`
`36`	`36`	`#include "runtime0.h"`
	`37`	`+#include "runtime.h"`
`37`	`38`
`38`	`39`	`#if MICROPY_ENABLE_FLOAT`
`39`	`40`
`@@ -74,7 +75,7 @@ STATIC void complex_print(void (print)(void env, const char fmt, ...), void `
`74`	`75`	`}`
`75`	`76`
`76`	`77`	`STATIC mp_obj_t complex_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {`
`77`		`- // TODO check n_kw == 0`
	`78`	`+ mp_arg_check_num(n_args, n_kw, 0, 2, false);`
`78`	`79`
`79`	`80`	`switch (n_args) {`
`80`	`81`	`case 0:`
`@@ -94,7 +95,8 @@ STATIC mp_obj_t complex_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const`
`94`	`95`	`return mp_obj_new_complex(mp_obj_get_float(args[0]), 0);`
`95`	`96`	`}`
`96`	`97`
`97`		`- case 2: {`
	`98`	`+ case 2:`
	`99`	`+ default: {`
`98`	`100`	`mp_float_t real, imag;`
`99`	`101`	`if (MP_OBJ_IS_TYPE(args[0], &mp_type_complex)) {`
`100`	`102`	`mp_obj_complex_get(args[0], &real, &imag);`
`@@ -112,9 +114,6 @@ STATIC mp_obj_t complex_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const`
`112`	`114`	`}`
`113`	`115`	`return mp_obj_new_complex(real, imag);`
`114`	`116`	`}`
`115`		`-`
`116`		`- default:`
`117`		`- nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "complex takes at most 2 arguments, %d given", n_args));`
`118`	`117`	`}`
`119`	`118`	`}`
`120`	`119`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@`
`46`	`46`
`47`	`47`	`// This dispatcher function is expected to be independent of the implementation of long int`
`48`	`48`	`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) {`
`49`		`- // TODO check n_kw == 0`
	`49`	`+ mp_arg_check_num(n_args, n_kw, 0, 2, false);`
`50`	`50`
`51`	`51`	`switch (n_args) {`
`52`	`52`	`case 0:`
`@@ -67,16 +67,13 @@ STATIC mp_obj_t mp_obj_int_make_new(mp_obj_t type_in, uint n_args, uint n_kw, co`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`case 2:`
`70`		`- {`
	`70`	`+ default: {`
`71`	`71`	`// should be a string, parse it`
`72`	`72`	`// TODO proper error checking of argument types`
`73`	`73`	`uint l;`
`74`	`74`	`const char *s = mp_obj_str_get_data(args[0], &l);`
`75`	`75`	`return mp_parse_num_integer(s, l, mp_obj_get_int(args[1]));`
`76`	`76`	`}`
`77`		`-`
`78`		`- default:`
`79`		`- nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "int takes at most 2 arguments, %d given", n_args));`
`80`	`77`	`}`
`81`	`78`	`}`
`82`	`79`
Original file line number	Diff line number	Diff line change
`@@ -69,23 +69,20 @@ STATIC mp_obj_t list_extend_from_iter(mp_obj_t list, mp_obj_t iterable) {`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`STATIC mp_obj_t list_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {`
`72`		`- // TODO check n_kw == 0`
	`72`	`+ mp_arg_check_num(n_args, n_kw, 0, 1, false);`
`73`	`73`
`74`	`74`	`switch (n_args) {`
`75`	`75`	`case 0:`
`76`	`76`	`// return a new, empty list`
`77`	`77`	`return mp_obj_new_list(0, NULL);`
`78`	`78`
`79`	`79`	`case 1:`
`80`		`- {`
	`80`	`+ default: {`
`81`	`81`	`// make list from iterable`
`82`	`82`	`// TODO: optimize list/tuple`
`83`	`83`	`mp_obj_t list = mp_obj_new_list(0, NULL);`
`84`	`84`	`return list_extend_from_iter(list, args[0]);`
`85`	`85`	`}`
`86`		`-`
`87`		`- default:`
`88`		`- nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "list takes at most 1 argument, %d given", n_args));`
`89`	`86`	`}`
`90`	`87`	`}`
`91`	`88`
Original file line number	Diff line number	Diff line change
`@@ -57,14 +57,15 @@ void mp_obj_tuple_print(void (print)(void env, const char fmt, ...), void en`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`STATIC mp_obj_t mp_obj_tuple_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {`
`60`		`- // TODO check n_kw == 0`
	`60`	`+ mp_arg_check_num(n_args, n_kw, 0, 1, false);`
`61`	`61`
`62`	`62`	`switch (n_args) {`
`63`	`63`	`case 0:`
`64`	`64`	`// return a empty tuple`
`65`	`65`	`return mp_const_empty_tuple;`
`66`	`66`
`67`		`- case 1: {`
	`67`	`+ case 1:`
	`68`	`+ default: {`
`68`	`69`	`// 1 argument, an iterable from which we make a new tuple`
`69`	`70`	`if (MP_OBJ_IS_TYPE(args[0], &mp_type_tuple)) {`
`70`	`71`	`return args[0];`
`@@ -91,9 +92,6 @@ STATIC mp_obj_t mp_obj_tuple_make_new(mp_obj_t type_in, uint n_args, uint n_kw,`
`91`	`92`
`92`	`93`	`return tuple;`
`93`	`94`	`}`
`94`		`-`
`95`		`- default:`
`96`		`- nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "tuple takes at most 1 argument, %d given", n_args));`
`97`	`95`	`}`
`98`	`96`	`}`
`99`	`97`
Original file line number	Diff line number	Diff line change
`@@ -540,7 +540,7 @@ STATIC void type_print(void (print)(void env, const char fmt, ...), void env`
`540`	`540`	`}`
`541`	`541`
`542`	`542`	`STATIC mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {`
`543`		`- // TODO check n_kw == 0`
	`543`	`+ mp_arg_check_num(n_args, n_kw, 1, 3, false);`
`544`	`544`
`545`	`545`	`switch (n_args) {`
`546`	`546`	`case 1:`