Optimizations by Sjoerd:

- define tp_getattro, tp_setattro
- use precreated string objects for most common exceptions and method names

1 files changed, 172 insertions, 81 deletions

diff --git a/Objects/classobject.c b/Objects/classobject.c
index 27f1f26..d3c46b3 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -28,8 +28,8 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "structmember.h"
 
 /* Forward */
-static object *class_lookup PROTO((classobject *, char *, classobject **));
-static object *instance_getattr1 PROTO((instanceobject *, char *));
+static object *class_lookup PROTO((classobject *, object *, classobject **));
+static object *instance_getattr1 PROTO((instanceobject *, object *));
 
 object *
 newclassobject(bases, dict, name)
@@ -40,6 +40,7 @@ newclassobject(bases, dict, name)
 	int pos;
 	object *key, *value;
 	classobject *op, *dummy;
+	static object *getattrstr, *setattrstr, *delattrstr;
 	if (dictlookup(dict, "__doc__") == NULL) {
 		if (dictinsert(dict, "__doc__", None) < 0)
 			return NULL;
@@ -61,9 +62,14 @@ newclassobject(bases, dict, name)
 	op->cl_dict = dict;
 	XINCREF(name);
 	op->cl_name = name;
-	op->cl_getattr = class_lookup(op, "__getattr__", &dummy);
-	op->cl_setattr = class_lookup(op, "__setattr__", &dummy);
-	op->cl_delattr = class_lookup(op, "__delattr__", &dummy);
+	if (getattrstr == NULL) {
+		getattrstr = newstringobject("__getattr__");
+		setattrstr = newstringobject("__setattr__");
+		delattrstr = newstringobject("__delattr__");
+	}
+	op->cl_getattr = class_lookup(op, getattrstr, &dummy);
+	op->cl_setattr = class_lookup(op, setattrstr, &dummy);
+	op->cl_delattr = class_lookup(op, delattrstr, &dummy);
 	XINCREF(op->cl_getattr);
 	XINCREF(op->cl_setattr);
 	XINCREF(op->cl_delattr);
@@ -90,11 +96,11 @@ class_dealloc(op)
 static object *
 class_lookup(cp, name, pclass)
 	classobject *cp;
-	char *name;
+	object *name;
 	classobject **pclass;
 {
 	int i, n;
-	object *value = dictlookup(cp->cl_dict, name);
+	object *value = mappinglookup(cp->cl_dict, name);
 	if (value != NULL) {
 		*pclass = cp;
 		return value;
@@ -112,12 +118,13 @@ class_lookup(cp, name, pclass)
 static object *
 class_getattr(op, name)
 	register classobject *op;
-	register char *name;
+	object *name;
 {
 	register object *v;
+	register char *sname = getstringvalue(name);
 	classobject *class;
-	if (name[0] == '_' && name[1] == '_') {
-		if (strcmp(name, "__dict__") == 0) {
+	if (sname[0] == '_' && sname[1] == '_') {
+		if (strcmp(sname, "__dict__") == 0) {
 			if (getrestricted()) {
 				err_setstr(RuntimeError,
 					   "class.__dict__ not accessible in restricted mode");
@@ -126,11 +133,11 @@ class_getattr(op, name)
 			INCREF(op->cl_dict);
 			return op->cl_dict;
 		}
-		if (strcmp(name, "__bases__") == 0) {
+		if (strcmp(sname, "__bases__") == 0) {
 			INCREF(op->cl_bases);
 			return op->cl_bases;
 		}
-		if (strcmp(name, "__name__") == 0) {
+		if (strcmp(sname, "__name__") == 0) {
 			if (op->cl_name == NULL)
 				v = None;
 			else
@@ -141,7 +148,7 @@ class_getattr(op, name)
 	}
 	v = class_lookup(op, name, &class);
 	if (v == NULL) {
-		err_setstr(AttributeError, name);
+		err_setval(AttributeError, name);
 		return NULL;
 	}
 	if (is_accessobject(v)) {
@@ -163,13 +170,14 @@ class_getattr(op, name)
 static int
 class_setattr(op, name, v)
 	classobject *op;
-	char *name;
+	object *name;
 	object *v;
 {
 	object *ac;
-	if (name[0] == '_' && name[1] == '_') {
-		int n = strlen(name);
-		if (name[n-1] == '_' && name[n-2] == '_') {
+	char *sname = getstringvalue(name);
+	if (sname[0] == '_' && sname[1] == '_') {
+		int n = getstringsize(name);
+		if (sname[n-1] == '_' && sname[n-2] == '_') {
 			err_setstr(TypeError, "read-only special attribute");
 			return -1;
 		}
@@ -179,18 +187,18 @@ class_setattr(op, name, v)
 			   "classes are read-only in restricted mode");
 		return -1;
 	}
-	ac = dictlookup(op->cl_dict, name);
+	ac = mappinglookup(op->cl_dict, name);
 	if (ac != NULL && is_accessobject(ac))
 		return setaccessvalue(ac, getowner(), v);
 	if (v == NULL) {
-		int rv = dictremove(op->cl_dict, name);
+		int rv = mappingremove(op->cl_dict, name);
 		if (rv < 0)
 			err_setstr(AttributeError,
 				   "delete non-existing class attribute");
 		return rv;
 	}
 	else
-		return dictinsert(op->cl_dict, name, v);
+		return mappinginsert(op->cl_dict, name, v);
 }
 
 static object *
@@ -215,13 +223,18 @@ typeobject Classtype = {
 	0,
 	(destructor)class_dealloc, /*tp_dealloc*/
 	0,		/*tp_print*/
-	(getattrfunc)class_getattr, /*tp_getattr*/
-	(setattrfunc)class_setattr, /*tp_setattr*/
+	0,		/*tp_getattr*/
+	0,		/*tp_setattr*/
 	0,		/*tp_compare*/
 	(reprfunc)class_repr, /*tp_repr*/
 	0,		/*tp_as_number*/
 	0,		/*tp_as_sequence*/
 	0,		/*tp_as_mapping*/
+	0,		/*tp_hash*/
+	0,		/*tp_call*/
+	0,		/*tp_str*/
+	(getattrofunc)class_getattr, /*tp_getattro*/
+	(setattrofunc)class_setattr, /*tp_setattro*/
 };
 
 int
@@ -291,6 +304,7 @@ newinstanceobject(class, arg, kw)
 {
 	register instanceobject *inst;
 	object *init;
+	static object *initstr;
 	if (!is_classobject(class)) {
 		err_badcall();
 		return NULL;
@@ -306,7 +320,9 @@ newinstanceobject(class, arg, kw)
 		DECREF(inst);
 		return NULL;
 	}
-	init = instance_getattr1(inst, "__init__");
+	if (initstr == NULL)
+		initstr = newstringobject("__init__");
+	init = instance_getattr1(inst, initstr);
 	if (init == NULL) {
 		err_clear();
 		if (arg != NULL && (!is_tupleobject(arg) ||
@@ -345,6 +361,7 @@ instance_dealloc(inst)
 {
 	object *error_type, *error_value, *error_traceback;
 	object *del;
+	static object *delstr;
 	/* Call the __del__ method if it exists.  First temporarily
 	   revive the object and save the current exception, if any. */
 #ifdef Py_TRACE_REFS
@@ -360,7 +377,9 @@ instance_dealloc(inst)
 	INCREF(inst);
 #endif /* !Py_TRACE_REFS */
 	err_fetch(&error_type, &error_value, &error_traceback);
-	if ((del = instance_getattr1(inst, "__del__")) != NULL) {
+	if (delstr == NULL)
+		delstr = newstringobject("__del__");
+	if ((del = instance_getattr1(inst, delstr)) != NULL) {
 		object *res = call_object(del, (object *)NULL);
 		DECREF(del);
 		XDECREF(res);
@@ -390,12 +409,13 @@ instance_dealloc(inst)
 static object *
 instance_getattr1(inst, name)
 	register instanceobject *inst;
-	register char *name;
+	object *name;
 {
 	register object *v;
+	register char *sname = getstringvalue(name);
 	classobject *class;
-	if (name[0] == '_' && name[1] == '_') {
-		if (strcmp(name, "__dict__") == 0) {
+	if (sname[0] == '_' && sname[1] == '_') {
+		if (strcmp(sname, "__dict__") == 0) {
 			if (getrestricted()) {
 				err_setstr(RuntimeError,
 					   "instance.__dict__ not accessible in restricted mode");
@@ -404,17 +424,17 @@ instance_getattr1(inst, name)
 			INCREF(inst->in_dict);
 			return inst->in_dict;
 		}
-		if (strcmp(name, "__class__") == 0) {
+		if (strcmp(sname, "__class__") == 0) {
 			INCREF(inst->in_class);
 			return (object *)inst->in_class;
 		}
 	}
 	class = NULL;
-	v = dictlookup(inst->in_dict, name);
+	v = mappinglookup(inst->in_dict, name);
 	if (v == NULL) {
 		v = class_lookup(inst->in_class, name, &class);
 		if (v == NULL) {
-			err_setstr(AttributeError, name);
+			err_setval(AttributeError, name);
 			return NULL;
 		}
 	}
@@ -450,14 +470,14 @@ instance_getattr1(inst, name)
 static object *
 instance_getattr(inst, name)
 	register instanceobject *inst;
-	register char *name;
+	object *name;
 {
 	register object *func, *res;
 	res = instance_getattr1(inst, name);
 	if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
 		object *args;
 		err_clear();
-		args = mkvalue("(Os)", inst, name);
+		args = mkvalue("(OO)", inst, name);
 		if (args == NULL)
 			return NULL;
 		res = call_object(func, args);
@@ -469,36 +489,37 @@ instance_getattr(inst, name)
 static int
 instance_setattr1(inst, name, v)
 	instanceobject *inst;
-	char *name;
+	object *name;
 	object *v;
 {
 	object *ac;
-	ac = dictlookup(inst->in_dict, name);
+	ac = mappinglookup(inst->in_dict, name);
 	if (ac != NULL && is_accessobject(ac))
 		return setaccessvalue(ac, getowner(), v);
 	if (v == NULL) {
-		int rv = dictremove(inst->in_dict, name);
+		int rv = mappingremove(inst->in_dict, name);
 		if (rv < 0)
 			err_setstr(AttributeError,
 				   "delete non-existing instance attribute");
 		return rv;
 	}
 	else
-		return dictinsert(inst->in_dict, name, v);
+		return mappinginsert(inst->in_dict, name, v);
 }
 
 static int
 instance_setattr(inst, name, v)
 	instanceobject *inst;
-	char *name;
+	object *name;
 	object *v;
 {
 	object *func, *args, *res;
-	if (name[0] == '_' && name[1] == '_'
-	    && (strcmp(name, "__dict__") == 0 ||
-		strcmp(name, "__class__") == 0)) {
-	        int n = strlen(name);
-		if (name[n-1] == '_' && name[n-2] == '_') {
+	char *sname = getstringvalue(name);
+	if (sname[0] == '_' && sname[1] == '_'
+	    && (strcmp(sname, "__dict__") == 0 ||
+		strcmp(sname, "__class__") == 0)) {
+	        int n = strlen(sname);
+		if (sname[n-1] == '_' && sname[n-2] == '_') {
 			err_setstr(TypeError, "read-only special attribute");
 			return -1;
 		}
@@ -510,9 +531,9 @@ instance_setattr(inst, name, v)
 	if (func == NULL)
 		return instance_setattr1(inst, name, v);
 	if (v == NULL)
-		args = mkvalue("(Os)", inst, name);
+		args = mkvalue("(OO)", inst, name);
 	else
-		args = mkvalue("(OsO)", inst, name, v);
+		args = mkvalue("(OOO)", inst, name, v);
 	if (args == NULL)
 		return -1;
 	res = call_object(func, args);
@@ -529,8 +550,11 @@ instance_repr(inst)
 {
 	object *func;
 	object *res;
+	static object *reprstr;
 
-	func = instance_getattr(inst, "__repr__");
+	if (reprstr == NULL)
+		reprstr = newstringobject("__repr__");
+	func = instance_getattr(inst, reprstr);
 	if (func == NULL) {
 		char buf[140];
 		object *classname = inst->in_class->cl_name;
@@ -584,13 +608,18 @@ instance_hash(inst)
 	object *func;
 	object *res;
 	long outcome;
+	static object *hashstr, *cmpstr;
 
-	func = instance_getattr(inst, "__hash__");
+	if (hashstr == NULL)
+		hashstr = newstringobject("__hash__");
+	func = instance_getattr(inst, hashstr);
 	if (func == NULL) {
 		/* If there is no __cmp__ method, we hash on the address.
 		   If a __cmp__ method exists, there must be a __hash__. */
 		err_clear();
-		func = instance_getattr(inst, "__cmp__");
+		if (cmpstr == NULL)
+			cmpstr = newstringobject("__cmp__");
+		func = instance_getattr(inst, cmpstr);
 		if (func == NULL) {
 			err_clear();
 			outcome = (long)inst;
@@ -618,6 +647,8 @@ instance_hash(inst)
 	return outcome;
 }
 
+static object *getitemstr, *setitemstr, *delitemstr, *lenstr;
+
 static int
 instance_length(inst)
 	instanceobject *inst;
@@ -626,7 +657,9 @@ instance_length(inst)
 	object *res;
 	int outcome;
 
-	func = instance_getattr(inst, "__len__");
+	if (lenstr == NULL)
+		lenstr = newstringobject("__len__");
+	func = instance_getattr(inst, lenstr);
 	if (func == NULL)
 		return -1;
 	res = call_object(func, (object *)NULL);
@@ -655,7 +688,9 @@ instance_subscript(inst, key)
 	object *arg;
 	object *res;
 
-	func = instance_getattr(inst, "__getitem__");
+	if (getitemstr == NULL)
+		getitemstr = newstringobject("__getitem__");
+	func = instance_getattr(inst, getitemstr);
 	if (func == NULL)
 		return NULL;
 	arg = mkvalue("(O)", key);
@@ -679,10 +714,16 @@ instance_ass_subscript(inst, key, value)
 	object *arg;
 	object *res;
 
-	if (value == NULL)
-		func = instance_getattr(inst, "__delitem__");
-	else
-		func = instance_getattr(inst, "__setitem__");
+	if (value == NULL) {
+		if (delitemstr == NULL)
+			delitemstr = newstringobject("__delitem__");
+		func = instance_getattr(inst, delitemstr);
+	}
+	else {
+		if (setitemstr == NULL)
+			setitemstr = newstringobject("__setitem__");
+		func = instance_getattr(inst, setitemstr);
+	}
 	if (func == NULL)
 		return -1;
 	if (value == NULL)
@@ -715,7 +756,9 @@ instance_item(inst, i)
 {
 	object *func, *arg, *res;
 
-	func = instance_getattr(inst, "__getitem__");
+	if (getitemstr == NULL)
+		getitemstr = newstringobject("__getitem__");
+	func = instance_getattr(inst, getitemstr);
 	if (func == NULL)
 		return NULL;
 	arg = mkvalue("(i)", i);
@@ -735,8 +778,11 @@ instance_slice(inst, i, j)
 	int i, j;
 {
 	object *func, *arg, *res;
+	static object *getslicestr;
 
-	func = instance_getattr(inst, "__getslice__");
+	if (getslicestr == NULL)
+		getslicestr = newstringobject("__getslice__");
+	func = instance_getattr(inst, getslicestr);
 	if (func == NULL)
 		return NULL;
 	arg = mkvalue("(ii)", i, j);
@@ -758,10 +804,16 @@ instance_ass_item(inst, i, item)
 {
 	object *func, *arg, *res;
 
-	if (item == NULL)
-		func = instance_getattr(inst, "__delitem__");
-	else
-		func = instance_getattr(inst, "__setitem__");
+	if (item == NULL) {
+		if (delitemstr == NULL)
+			delitemstr = newstringobject("__delitem__");
+		func = instance_getattr(inst, delitemstr);
+	}
+	else {
+		if (setitemstr == NULL)
+			setitemstr = newstringobject("__setitem__");
+		func = instance_getattr(inst, setitemstr);
+	}
 	if (func == NULL)
 		return -1;
 	if (item == NULL)
@@ -788,11 +840,18 @@ instance_ass_slice(inst, i, j, value)
 	object *value;
 {
 	object *func, *arg, *res;
+	static object *setslicestr, *delslicestr;
 
-	if (value == NULL)
-		func = instance_getattr(inst, "__delslice__");
-	else
-		func = instance_getattr(inst, "__setslice__");
+	if (value == NULL) {
+		if (delslicestr == NULL)
+			delslicestr = newstringobject("__delslice__");
+		func = instance_getattr(inst, delslicestr);
+	}
+	else {
+		if (setslicestr == NULL)
+			setslicestr = newstringobject("__setslice__");
+		func = instance_getattr(inst, setslicestr);
+	}
 	if (func == NULL)
 		return -1;
 	if (value == NULL)
@@ -825,7 +884,7 @@ static sequence_methods instance_as_sequence = {
 static object *
 generic_unary_op(self, methodname)
 	instanceobject *self;
-	char *methodname;
+	object *methodname;
 {
 	object *func, *res;
 
@@ -838,8 +897,8 @@ generic_unary_op(self, methodname)
 
 
 /* Forward */
-static int halfbinop PROTO((object *, object *, char *, object **,
-			    object * (*) PROTO((object *, object *)), int ));
+static int halfbinop Py_PROTO((object *, object *, char *, object **,
+			  object * (*) Py_PROTO((object *, object *)), int ));
 
 
 /* Implement a binary operator involving at least one class instance. */
@@ -871,6 +930,8 @@ instancebinop(v, w, opname, ropname, thisfunc)
    1  if we could try another operation
 */
 
+static object *coerce_obj;
+
 static int
 halfbinop(v, w, opname, r_result, thisfunc, swapped)
 	object *v;
@@ -888,7 +949,12 @@ halfbinop(v, w, opname, r_result, thisfunc, swapped)
 	
 	if (!is_instanceobject(v))
 		return 1;
-	coerce = getattr(v, "__coerce__");
+	if (coerce_obj == NULL) {
+		coerce_obj = newstringobject("__coerce__");
+		if (coerce_obj == NULL)
+			return -1;
+	}
+	coerce = getattro(v, coerce_obj);
 	if (coerce == NULL) {
 		err_clear();
 	}
@@ -960,7 +1026,12 @@ instance_coerce(pv, pw)
 	object *args;
 	object *coerced;
 
-	coerce = getattr(v, "__coerce__");
+	if (coerce_obj == NULL) {
+		coerce_obj = newstringobject("__coerce__");
+		if (coerce_obj == NULL)
+			return -1;
+	}
+	coerce = getattro(v, coerce_obj);
 	if (coerce == NULL) {
 		/* No __coerce__ method: always OK */
 		err_clear();
@@ -1004,7 +1075,9 @@ instance_coerce(pv, pw)
 
 #define UNARY(funcname, methodname) \
 static object *funcname(self) instanceobject *self; { \
-	return generic_unary_op(self, methodname); \
+	static object *o; \
+	if (o == NULL) o = newstringobject(methodname); \
+	return generic_unary_op(self, o); \
 }
 
 UNARY(instance_neg, "__neg__")
@@ -1017,10 +1090,15 @@ instance_nonzero(self)
 {
 	object *func, *res;
 	long outcome;
+	static object *nonzerostr;
 
-	if ((func = instance_getattr(self, "__nonzero__")) == NULL) {
+	if (nonzerostr == NULL)
+		nonzerostr = newstringobject("__nonzero__");
+	if ((func = instance_getattr(self, nonzerostr)) == NULL) {
 		err_clear();
-		if ((func = instance_getattr(self, "__len__")) == NULL) {
+		if (lenstr == NULL)
+			lenstr = newstringobject("__len__");
+		if ((func = instance_getattr(self, lenstr)) == NULL) {
 			err_clear();
 			/* Fall back to the default behavior:
 			   all instances are nonzero */
@@ -1063,7 +1141,11 @@ instance_pow(v, w, z)
 	object *func;
 	object *args;
 	object *result;
-	func = getattr(v, "__pow__");
+	static object *powstr;
+
+	if (powstr == NULL)
+		powstr = newstringobject("__pow__");
+	func = getattro(v, powstr);
 	if (func == NULL)
 		return NULL;
 	args = mkvalue("(OO)", w, z);
@@ -1111,14 +1193,18 @@ typeobject Instancetype = {
 	0,
 	(destructor)instance_dealloc, /*tp_dealloc*/
 	0,			/*tp_print*/
-	(getattrfunc)instance_getattr, /*tp_getattr*/
-	(setattrfunc)instance_setattr, /*tp_setattr*/
-	instance_compare, /*tp_compare*/
+	0,			/*tp_getattr*/
+	0,			/*tp_setattr*/
+	instance_compare,	/*tp_compare*/
 	(reprfunc)instance_repr, /*tp_repr*/
 	&instance_as_number,	/*tp_as_number*/
 	&instance_as_sequence,	/*tp_as_sequence*/
 	&instance_as_mapping,	/*tp_as_mapping*/
 	(hashfunc)instance_hash, /*tp_hash*/
+	0,			/*tp_call*/
+	0,			/*tp_str*/
+	(getattrofunc)instance_getattr, /*tp_getattro*/
+	(setattrofunc)instance_setattr, /*tp_setattro*/
 };
 
 
@@ -1208,15 +1294,16 @@ static struct memberlist instancemethod_memberlist[] = {
 static object *
 instancemethod_getattr(im, name)
 	register instancemethodobject *im;
-	char *name;
+	object *name;
 {
-	if (name[0] == '_') {
+	char *sname = getstringvalue(name);
+	if (sname[0] == '_') {
 		funcobject *func = (funcobject *)(im->im_func);
-		if (strcmp(name, "__name__") == 0) {
+		if (strcmp(sname, "__name__") == 0) {
 			INCREF(func->func_name);
 			return func->func_name;
 		}
-		if (strcmp(name, "__doc__") == 0) {
+		if (strcmp(sname, "__doc__") == 0) {
 			INCREF(func->func_doc);
 			return func->func_doc;
 		}
@@ -1226,7 +1313,7 @@ instancemethod_getattr(im, name)
 			   "instance-method attributes not accessible in restricted mode");
 		return NULL;
 	}
-	return getmember((char *)im, instancemethod_memberlist, name);
+	return getmember((char *)im, instancemethod_memberlist, sname);
 }
 
 static void
@@ -1307,7 +1394,7 @@ typeobject Instancemethodtype = {
 	0,
 	(destructor)instancemethod_dealloc, /*tp_dealloc*/
 	0,			/*tp_print*/
-	(getattrfunc)instancemethod_getattr, /*tp_getattr*/
+	0,			/*tp_getattr*/
 	0,			/*tp_setattr*/
 	(cmpfunc)instancemethod_compare, /*tp_compare*/
 	(reprfunc)instancemethod_repr, /*tp_repr*/
@@ -1315,4 +1402,8 @@ typeobject Instancemethodtype = {
 	0,			/*tp_as_sequence*/
 	0,			/*tp_as_mapping*/
 	(hashfunc)instancemethod_hash, /*tp_hash*/
+	0,			/*tp_call*/
+	0,			/*tp_str*/
+	(getattrofunc)instancemethod_getattr, /*tp_getattro*/
+	0,			/*tp_setattro*/
 };