Add PyUnicode_AsStringAndSize(), which is like PyUnicode_AsString() but

has an extra (optional) output parameter through which it returns the size.
Use this in a few places where I used PyUnicode_AsString() + strlen(),
and in one new place (which fixes test_pep263).

4 files changed, 31 insertions, 17 deletions

diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h
index 4d8e45a..4374857 100644
--- a/Include/unicodeobject.h
+++ b/Include/unicodeobject.h
@@ -641,20 +641,25 @@ PyAPI_FUNC(PyObject*) PyUnicode_FromOrdinal(int ordinal);
 PyAPI_FUNC(PyObject *) _PyUnicode_AsDefaultEncodedString(
     PyObject *, const char *);
 
-/* Return a char* holding the default encoded value of the
-   Unicode object. 
+/* Return a char* holding the UTF-8 encoded value of the
+   Unicode object.
+
+   DEPRECATED: use PyUnicode_AsStringAndSize() instead.
 */
 
+PyAPI_FUNC(char *) PyUnicode_AsStringAndSize(PyObject*, Py_ssize_t *);
+
+/* Returns the UTF-8 encoding, and its size.
+
+   If the output argument is NULL, no size is stored.
+ */
+
 PyAPI_FUNC(char *) PyUnicode_AsString(PyObject*);
 
+/* Returns the UTF-8 encoding.
 
-/* Returns the currently active default encoding.
+   This is equivalent to PyUnicode_AsStringAndSize(x, NULL).
 
-   The default encoding is currently implemented as run-time settable
-   process global.  This may change in future versions of the
-   interpreter to become a parameter which is managed on a per-thread
-   basis.
-   
  */
 
 PyAPI_FUNC(const char*) PyUnicode_GetDefaultEncoding(void);
diff --git a/Modules/_sqlite/statement.c b/Modules/_sqlite/statement.c
index a5801d6..b1a4e76 100644
--- a/Modules/_sqlite/statement.c
+++ b/Modules/_sqlite/statement.c
@@ -50,12 +50,11 @@ int pysqlite_statement_create(pysqlite_Statement* self, pysqlite_Connection* con
     self->st = NULL;
     self->in_use = 0;
 
-    sql_cstr = PyUnicode_AsString(sql);
+    sql_cstr = PyUnicode_AsStringAndSize(sql, &sql_cstr_len);
     if (sql_cstr == NULL) {
         rc = PYSQLITE_SQL_WRONG_TYPE;
         return rc;
     }
-    sql_cstr_len = strlen(sql_cstr); /* XXX */
 
     self->in_weakreflist = NULL;
     Py_INCREF(sql);
@@ -216,12 +215,11 @@ int pysqlite_statement_recompile(pysqlite_Statement* self, PyObject* params)
     Py_ssize_t sql_len;
     sqlite3_stmt* new_st;
 
-    sql_cstr = PyUnicode_AsString(self->sql);
+    sql_cstr = PyUnicode_AsStringAndSize(self->sql, &sql_len);
     if (sql_cstr == NULL) {
         rc = PYSQLITE_SQL_WRONG_TYPE;
         return rc;
     }
-    sql_len = strlen(sql_cstr); /* XXXX */
 
     rc = sqlite3_prepare(self->db,
                          sql_cstr,
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index 4e8b2ed..9de1e53 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -1184,16 +1184,25 @@ PyObject *_PyUnicode_AsDefaultEncodedString(PyObject *unicode,
 }
 
 char*
-PyUnicode_AsString(PyObject *unicode)
+PyUnicode_AsStringAndSize(PyObject *unicode, Py_ssize_t *psize)
 {
+    PyObject *str8;
     if (!PyUnicode_Check(unicode)) {
         PyErr_BadArgument();
         return NULL;
     }
-    unicode = _PyUnicode_AsDefaultEncodedString(unicode, NULL);
-    if (!unicode)
+    str8 = _PyUnicode_AsDefaultEncodedString(unicode, NULL);
+    if (str8 == NULL)
         return NULL;
-    return PyString_AsString(unicode);
+    if (psize != NULL)
+        *psize = PyString_GET_SIZE(str8);
+    return PyString_AS_STRING(str8);
+}
+
+char*
+PyUnicode_AsString(PyObject *unicode)
+{
+    return PyUnicode_AsStringAndSize(unicode, NULL);
 }
 
 Py_UNICODE *PyUnicode_AsUnicode(PyObject *unicode)
@@ -8098,6 +8107,7 @@ unicode_buffer_getbuffer(PyUnicodeObject *self, PyBuffer *view, int flags)
 
     if (flags & PyBUF_CHARACTER) {
         PyErr_SetString(PyExc_SystemError, "can't use str as char buffer");
+        abort();
         return -1;
     }
     return PyBuffer_FillInfo(view, (void *)self->str,
diff --git a/Parser/tokenizer.c b/Parser/tokenizer.c
index 8f30fef..6320f75 100644
--- a/Parser/tokenizer.c
+++ b/Parser/tokenizer.c
@@ -383,7 +383,8 @@ fp_readl(char *s, int size, struct tok_state *tok)
 			goto error;
 		allocated = 1;
 	}
-        if (PyObject_AsCharBuffer(bufobj, &buf, &buflen) < 0) {
+	buf = PyUnicode_AsStringAndSize(bufobj, &buflen);
+	if (buf == NULL) {
 		goto error;
 	}
 	if (buflen > size) {