In preparation for Python 3 support, all reprs now return unicodes, which is

legal in Python 2 also.  Use fancy REPR macro and the %V format code for
cross-Python compatibility.

5 files changed, 92 insertions, 67 deletions

diff --git a/_dbus_bindings/abstract.c b/_dbus_bindings/abstract.c
index 6d77819..7683fbe 100644
--- a/_dbus_bindings/abstract.c
+++ b/_dbus_bindings/abstract.c
@@ -200,14 +200,14 @@ DBusPythonInt_tp_repr(PyObject *self)
 
     if (!parent_repr) return NULL;
     if (variant_level > 0) {
-        my_repr = PyString_FromFormat("%s(%s, variant_level=%ld)",
-                                      Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      variant_level);
+        my_repr = PyUnicode_FromFormat("%s(%V, variant_level=%ld)",
+                                       Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr),
+                                       variant_level);
     }
     else {
-        my_repr = PyString_FromFormat("%s(%s)", Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr));
+        my_repr = PyUnicode_FromFormat("%s(%V)", Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr));
     }
     /* whether my_repr is NULL or not: */
     Py_CLEAR(parent_repr);
@@ -311,14 +311,14 @@ DBusPythonFloat_tp_repr(PyObject *self)
 
     if (!parent_repr) return NULL;
     if (variant_level > 0) {
-        my_repr = PyString_FromFormat("%s(%s, variant_level=%ld)",
-                                      Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      variant_level);
+        my_repr = PyUnicode_FromFormat("%s(%V, variant_level=%ld)",
+                                       Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr),
+                                       variant_level);
     }
     else {
-        my_repr = PyString_FromFormat("%s(%s)", Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr));
+        my_repr = PyUnicode_FromFormat("%s(%V)", Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr));
     }
     /* whether my_repr is NULL or not: */
     Py_CLEAR(parent_repr);
@@ -421,14 +421,14 @@ DBusPythonString_tp_repr(PyObject *self)
     variant_level = PyInt_AsLong(vl_obj);
     Py_CLEAR(vl_obj);
     if (variant_level > 0) {
-        my_repr = PyString_FromFormat("%s(%s, variant_level=%ld)",
-                                      Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      variant_level);
+        my_repr = PyUnicode_FromFormat("%s(%V, variant_level=%ld)",
+                                       Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr),
+                                       variant_level);
     }
     else {
-        my_repr = PyString_FromFormat("%s(%s)", Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr));
+        my_repr = PyUnicode_FromFormat("%s(%V)", Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr));
     }
     /* whether my_repr is NULL or not: */
     Py_CLEAR(parent_repr);
@@ -538,14 +538,14 @@ DBusPythonLong_tp_repr(PyObject *self)
     variant_level = PyInt_AsLong(vl_obj);
     Py_CLEAR(vl_obj);
     if (variant_level) {
-        my_repr = PyString_FromFormat("%s(%s, variant_level=%ld)",
-                                      Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      variant_level);
+        my_repr = PyUnicode_FromFormat("%s(%V, variant_level=%ld)",
+                                       Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr),
+                                       variant_level);
     }
     else {
-        my_repr = PyString_FromFormat("%s(%s)", Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr));
+        my_repr = PyUnicode_FromFormat("%s(%V)", Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr));
     }
     /* whether my_repr is NULL or not: */
     Py_CLEAR(parent_repr);
diff --git a/_dbus_bindings/containers.c b/_dbus_bindings/containers.c
index c9df288..bc07f12 100644
--- a/_dbus_bindings/containers.c
+++ b/_dbus_bindings/containers.c
@@ -92,18 +92,18 @@ Array_tp_repr(DBusPyArray *self)
     if (!parent_repr) goto finally;
     if (!sig_repr) goto finally;
     if (variant_level > 0) {
-        my_repr = PyString_FromFormat("%s(%s, signature=%s, "
-                                      "variant_level=%ld)",
-                                      Py_TYPE(&self->super)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      PyString_AS_STRING(sig_repr),
-                                      variant_level);
+        my_repr = PyUnicode_FromFormat("%s(%V, signature=%V, "
+                                       "variant_level=%ld)",
+                                       Py_TYPE(&self->super)->tp_name,
+                                       REPRV(parent_repr),
+                                       REPRV(sig_repr),
+                                       variant_level);
     }
     else {
-        my_repr = PyString_FromFormat("%s(%s, signature=%s)",
-                                      Py_TYPE(&self->super)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      PyString_AS_STRING(sig_repr));
+        my_repr = PyUnicode_FromFormat("%s(%V, signature=%V)",
+                                       Py_TYPE(&self->super)->tp_name,
+                                       REPRV(parent_repr),
+                                       REPRV(sig_repr));
     }
 finally:
     Py_CLEAR(parent_repr);
@@ -299,18 +299,18 @@ Dict_tp_repr(DBusPyDict *self)
     if (!parent_repr) goto finally;
     if (!sig_repr) goto finally;
     if (variant_level > 0) {
-        my_repr = PyString_FromFormat("%s(%s, signature=%s, "
-                                      "variant_level=%ld)",
-                                      Py_TYPE(&self->super)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      PyString_AS_STRING(sig_repr),
-                                      variant_level);
+        my_repr = PyUnicode_FromFormat("%s(%V, signature=%V, "
+                                       "variant_level=%ld)",
+                                       Py_TYPE(&self->super)->tp_name,
+                                       REPRV(parent_repr),
+                                       REPRV(sig_repr),
+                                       variant_level);
     }
     else {
-        my_repr = PyString_FromFormat("%s(%s, signature=%s)",
-                                      Py_TYPE(&self->super)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      PyString_AS_STRING(sig_repr));
+        my_repr = PyUnicode_FromFormat("%s(%V, signature=%V)",
+                                       Py_TYPE(&self->super)->tp_name,
+                                       REPRV(parent_repr),
+                                       REPRV(sig_repr));
     }
 finally:
     Py_CLEAR(parent_repr);
@@ -521,18 +521,18 @@ Struct_tp_repr(PyObject *self)
     if (!sig_repr) goto finally;
     variant_level = dbus_py_variant_level_get(self);
     if (variant_level > 0) {
-        my_repr = PyString_FromFormat("%s(%s, signature=%s, "
-                                      "variant_level=%ld)",
-                                      Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      PyString_AS_STRING(sig_repr),
-                                      variant_level);
+        my_repr = PyUnicode_FromFormat("%s(%V, signature=%V, "
+                                       "variant_level=%ld)",
+                                       Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr),
+                                       REPRV(sig_repr),
+                                       variant_level);
     }
     else {
-        my_repr = PyString_FromFormat("%s(%s, signature=%s)",
-                                      Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      PyString_AS_STRING(sig_repr));
+        my_repr = PyUnicode_FromFormat("%s(%V, signature=%V)",
+                                       Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr),
+                                       REPRV(sig_repr));
     }
 
 finally:
diff --git a/_dbus_bindings/dbus_bindings-internal.h b/_dbus_bindings/dbus_bindings-internal.h
index fd2efb6..d33e9c7 100644
--- a/_dbus_bindings/dbus_bindings-internal.h
+++ b/_dbus_bindings/dbus_bindings-internal.h
@@ -51,6 +51,31 @@ static inline int type##_CheckExact (PyObject *o) \
     return (Py_TYPE(o) == &type##_Type); \
 }
 
+/* This is a clever little trick to make writing the various object reprs
+ * easier.  It relies on Python's %V format option which consumes two
+ * arguments.  The first is a unicode object which may be NULL, and the second
+ * is a char* which will be used if the first parameter is NULL.
+ *
+ * The issue is that we don't know whether the `parent_repr` at the call site
+ * is a unicode or a bytes (a.k.a. 8-bit string).  Under Python 3, it will
+ * always be a unicode.  Under Python 2 it will *probably* be a bytes/str, but
+ * could potentially be a unicode.  So, we check the type, and if it's a
+ * unicode, we pass that as the first argument, leaving NULL as the second
+ * argument (since it will never be checked).  However, if the object is not a
+ * unicode, it better be a bytes.  In that case, we'll pass NULL as the first
+ * argument so that the second one gets used, and we'll dig the char* out of
+ * the bytes object for that purpose.
+ *
+ * You might think that this would crash if obj is neither a bytes/str or
+ * unicode, and you'd be right *except* that Python doesn't allow any other
+ * types to be returned in the reprs.  Also, since obj will always be the repr
+ * of a built-in type, it will never be anything other than a bytes or a
+ * unicode in any version of Python.  So in practice, this is safe.
+ */
+#define REPRV(obj) \
+    (PyUnicode_Check(obj) ? (obj) : NULL), \
+    (PyUnicode_Check(obj) ? NULL : PyBytes_AS_STRING(obj))
+
 PyMODINIT_FUNC init_dbus_bindings(void);
 
 /* conn.c */
diff --git a/_dbus_bindings/int.c b/_dbus_bindings/int.c
index cc5efff..1c4b2d4 100644
--- a/_dbus_bindings/int.c
+++ b/_dbus_bindings/int.c
@@ -75,14 +75,14 @@ Boolean_tp_repr (PyObject *self)
 {
     long variant_level = ((DBusPyIntBase *)self)->variant_level;
     if (variant_level > 0) {
-        return PyString_FromFormat("%s(%s, variant_level=%ld)",
-                                   Py_TYPE(self)->tp_name,
-                                   PyInt_AsLong(self) ? "True" : "False",
-                                   variant_level);
+        return PyUnicode_FromFormat("%s(%s, variant_level=%ld)",
+                                    Py_TYPE(self)->tp_name,
+                                    PyInt_AsLong(self) ? "True" : "False",
+                                    variant_level);
     }
-    return PyString_FromFormat("%s(%s)",
-                               Py_TYPE(self)->tp_name,
-                               PyInt_AsLong(self) ? "True" : "False");
+    return PyUnicode_FromFormat("%s(%s)",
+                                Py_TYPE(self)->tp_name,
+                                PyInt_AsLong(self) ? "True" : "False");
 }
 
 PyTypeObject DBusPyBoolean_Type = {
diff --git a/_dbus_bindings/string.c b/_dbus_bindings/string.c
index bdc94ec..33bb3af 100644
--- a/_dbus_bindings/string.c
+++ b/_dbus_bindings/string.c
@@ -273,14 +273,14 @@ String_tp_repr(PyObject *self)
         return NULL;
     }
     if (((DBusPyString *)self)->variant_level > 0) {
-        my_repr = PyString_FromFormat("%s(%s, variant_level=%ld)",
-                                      Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr),
-                                      ((DBusPyString *)self)->variant_level);
+        my_repr = PyUnicode_FromFormat("%s(%V, variant_level=%ld)",
+                                       Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr),
+                                       ((DBusPyString *)self)->variant_level);
     }
     else {
-        my_repr = PyString_FromFormat("%s(%s)", Py_TYPE(self)->tp_name,
-                                      PyString_AS_STRING(parent_repr));
+        my_repr = PyUnicode_FromFormat("%s(%V)", Py_TYPE(self)->tp_name,
+                                       REPRV(parent_repr));
     }
     /* whether my_repr is NULL or not: */
     Py_CLEAR(parent_repr);