Merged revisions 53875-53911 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r53899 | neal.norwitz | 2007-02-25 16:52:27 +0100 (Sun, 25 Feb 2007) | 1 line
Add more details when releasing interned strings
........
r53900 | neal.norwitz | 2007-02-25 16:53:36 +0100 (Sun, 25 Feb 2007) | 1 line
Whitespace only changes
........
r53901 | jeremy.hylton | 2007-02-25 16:57:45 +0100 (Sun, 25 Feb 2007) | 8 lines
Fix crash in exec when unicode filename can't be decoded.
I can't think of an easy way to test this behavior. It only occurs
when the file system default encoding and the interpreter default
encoding are different, such that you can open the file but not decode
its name.
........
r53902 | jeremy.hylton | 2007-02-25 17:01:58 +0100 (Sun, 25 Feb 2007) | 2 lines
Put declarations before code.
........
r53910 | fred.drake | 2007-02-25 18:56:27 +0100 (Sun, 25 Feb 2007) | 3 lines
- SF patch #1657613: add documentation for the Element interface
- clean up bogus use of the {datadescni} environment everywhere
........
r53911 | neal.norwitz | 2007-02-25 20:44:48 +0100 (Sun, 25 Feb 2007) | 17 lines
Variation of patch # 1624059 to speed up checking if an object is a subclass
of some of the common builtin types.
Use a bit in tp_flags for each common builtin type. Check the bit
to determine if any instance is a subclass of these common types.
The check avoids a function call and O(n) search of the base classes.
The check is done in the various Py*_Check macros rather than calling
PyType_IsSubtype().
All the bits are set in tp_flags when the type is declared
in the Objects/*object.c files because PyType_Ready() is not called
for all the types. Should PyType_Ready() be called for all types?
If so and the change is made, the changes to the Objects/*object.c files
can be reverted (remove setting the tp_flags). Objects/typeobject.c
would also have to be modified to add conditions
for Py*_CheckExact() in addition to each the PyType_IsSubtype check.
........
diff --git a/Include/dictobject.h b/Include/dictobject.h
index 44b0838..ec2e0c8 100644
--- a/Include/dictobject.h
+++ b/Include/dictobject.h
@@ -90,7 +90,8 @@
PyAPI_DATA(PyTypeObject) PyDict_Type;
-#define PyDict_Check(op) PyObject_TypeCheck(op, &PyDict_Type)
+#define PyDict_Check(op) \
+ PyType_FastSubclass((op)->ob_type, Py_TPFLAGS_DICT_SUBCLASS)
#define PyDict_CheckExact(op) ((op)->ob_type == &PyDict_Type)
PyAPI_FUNC(PyObject *) PyDict_New(void);
diff --git a/Include/listobject.h b/Include/listobject.h
index d9012ce..db3124e 100644
--- a/Include/listobject.h
+++ b/Include/listobject.h
@@ -40,7 +40,8 @@
PyAPI_DATA(PyTypeObject) PyList_Type;
-#define PyList_Check(op) PyObject_TypeCheck(op, &PyList_Type)
+#define PyList_Check(op) \
+ PyType_FastSubclass((op)->ob_type, Py_TPFLAGS_LIST_SUBCLASS)
#define PyList_CheckExact(op) ((op)->ob_type == &PyList_Type)
PyAPI_FUNC(PyObject *) PyList_New(Py_ssize_t size);
diff --git a/Include/longobject.h b/Include/longobject.h
index 7f2cda6..b7a29b5 100644
--- a/Include/longobject.h
+++ b/Include/longobject.h
@@ -11,7 +11,8 @@
PyAPI_DATA(PyTypeObject) PyLong_Type;
-#define PyLong_Check(op) PyObject_TypeCheck(op, &PyLong_Type)
+#define PyLong_Check(op) \
+ PyType_FastSubclass((op)->ob_type, Py_TPFLAGS_LONG_SUBCLASS)
#define PyLong_CheckExact(op) ((op)->ob_type == &PyLong_Type)
PyAPI_FUNC(PyObject *) PyLong_FromLong(long);
diff --git a/Include/object.h b/Include/object.h
index 0c5fa42..40e52e3 100644
--- a/Include/object.h
+++ b/Include/object.h
@@ -357,7 +357,8 @@
PyAPI_DATA(PyTypeObject) PyBaseObject_Type; /* built-in 'object' */
PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */
-#define PyType_Check(op) PyObject_TypeCheck(op, &PyType_Type)
+#define PyType_Check(op) \
+ PyType_FastSubclass((op)->ob_type, Py_TPFLAGS_TYPE_SUBCLASS)
#define PyType_CheckExact(op) ((op)->ob_type == &PyType_Type)
PyAPI_FUNC(int) PyType_Ready(PyTypeObject *);
@@ -469,11 +470,23 @@
#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION 0
#endif
+/* These flags are used to determine if a type is a subclass. */
+#define Py_TPFLAGS_INT_SUBCLASS (1L<<23)
+#define Py_TPFLAGS_LONG_SUBCLASS (1L<<24)
+#define Py_TPFLAGS_LIST_SUBCLASS (1L<<25)
+#define Py_TPFLAGS_TUPLE_SUBCLASS (1L<<26)
+#define Py_TPFLAGS_STRING_SUBCLASS (1L<<27)
+#define Py_TPFLAGS_UNICODE_SUBCLASS (1L<<28)
+#define Py_TPFLAGS_DICT_SUBCLASS (1L<<29)
+#define Py_TPFLAGS_BASE_EXC_SUBCLASS (1L<<30)
+#define Py_TPFLAGS_TYPE_SUBCLASS (1L<<31)
+
#define Py_TPFLAGS_DEFAULT ( \
Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \
0)
#define PyType_HasFeature(t,f) (((t)->tp_flags & (f)) != 0)
+#define PyType_FastSubclass(t,f) PyType_HasFeature(t,f)
/*
diff --git a/Include/pyerrors.h b/Include/pyerrors.h
index 67f1909..562af10 100644
--- a/Include/pyerrors.h
+++ b/Include/pyerrors.h
@@ -94,13 +94,12 @@
/* */
-#define PyExceptionClass_Check(x) \
- (PyType_Check((x)) && PyType_IsSubtype( \
- (PyTypeObject*)(x), (PyTypeObject*)PyExc_BaseException))
+#define PyExceptionClass_Check(x) \
+ (PyType_Check((x)) && \
+ PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
-
-#define PyExceptionInstance_Check(x) \
- (PyType_IsSubtype((x)->ob_type, (PyTypeObject*)PyExc_BaseException))
+#define PyExceptionInstance_Check(x) \
+ PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS)
#define PyExceptionClass_Name(x) \
((char *)(((PyTypeObject*)(x))->tp_name))
diff --git a/Include/stringobject.h b/Include/stringobject.h
index ef8f545..8156193 100644
--- a/Include/stringobject.h
+++ b/Include/stringobject.h
@@ -55,7 +55,8 @@
PyAPI_DATA(PyTypeObject) PyBaseString_Type;
PyAPI_DATA(PyTypeObject) PyString_Type;
-#define PyString_Check(op) PyObject_TypeCheck(op, &PyString_Type)
+#define PyString_Check(op) \
+ PyType_FastSubclass((op)->ob_type, Py_TPFLAGS_STRING_SUBCLASS)
#define PyString_CheckExact(op) ((op)->ob_type == &PyString_Type)
PyAPI_FUNC(PyObject *) PyString_FromStringAndSize(const char *, Py_ssize_t);
diff --git a/Include/tupleobject.h b/Include/tupleobject.h
index 8c37cab..738cea1 100644
--- a/Include/tupleobject.h
+++ b/Include/tupleobject.h
@@ -33,7 +33,8 @@
PyAPI_DATA(PyTypeObject) PyTuple_Type;
-#define PyTuple_Check(op) PyObject_TypeCheck(op, &PyTuple_Type)
+#define PyTuple_Check(op) \
+ PyType_FastSubclass((op)->ob_type, Py_TPFLAGS_TUPLE_SUBCLASS)
#define PyTuple_CheckExact(op) ((op)->ob_type == &PyTuple_Type)
PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size);
diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h
index 33aa185..0bad8c3 100644
--- a/Include/unicodeobject.h
+++ b/Include/unicodeobject.h
@@ -392,7 +392,8 @@
PyAPI_DATA(PyTypeObject) PyUnicode_Type;
-#define PyUnicode_Check(op) PyObject_TypeCheck(op, &PyUnicode_Type)
+#define PyUnicode_Check(op) \
+ PyType_FastSubclass((op)->ob_type, Py_TPFLAGS_UNICODE_SUBCLASS)
#define PyUnicode_CheckExact(op) ((op)->ob_type == &PyUnicode_Type)
/* Fast access macros */