From 78821ddf8c8eeebf757d72c2989cc0accea155de Mon Sep 17 00:00:00 2001 From: Benjamin Peterson Date: Sun, 25 Jan 2009 17:15:10 +0000 Subject: fix building the core with --disable-unicode I changed some bytearray methods to use strings instead of unicode like bytes_repr Also, bytearray.fromhex() can take strings as well as unicode --- Lib/test/test_bytes.py | 1 - Modules/gcmodule.c | 2 ++ Objects/abstract.c | 14 ++++++++++++++ Objects/bytearrayobject.c | 47 +++++++++++++++++++++++++++++----------------- Objects/typeobject.c | 4 ++++ Python/ceval.c | 19 +++++++++++++++---- Python/formatter_unicode.c | 5 +++++ 7 files changed, 70 insertions(+), 22 deletions(-) diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py index 8ac8898..09b497b 100644 --- a/Lib/test/test_bytes.py +++ b/Lib/test/test_bytes.py @@ -250,7 +250,6 @@ class BaseBytesTest(unittest.TestCase): self.assertEquals(self.type2test.fromhex(u'1a2B30'), b) self.assertEquals(self.type2test.fromhex(u' 1A 2B 30 '), b) self.assertEquals(self.type2test.fromhex(u'0000'), b'\0\0') - self.assertRaises(TypeError, self.type2test.fromhex, b'1B') self.assertRaises(ValueError, self.type2test.fromhex, u'a') self.assertRaises(ValueError, self.type2test.fromhex, u'rt') self.assertRaises(ValueError, self.type2test.fromhex, u'1a b cd') diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c index 9b47819..4d71591 100644 --- a/Modules/gcmodule.c +++ b/Modules/gcmodule.c @@ -784,7 +784,9 @@ clear_freelists(void) (void)PyFrame_ClearFreeList(); (void)PyCFunction_ClearFreeList(); (void)PyTuple_ClearFreeList(); +#ifdef Py_USING_UNICODE (void)PyUnicode_ClearFreeList(); +#endif (void)PyInt_ClearFreeList(); (void)PyFloat_ClearFreeList(); } diff --git a/Objects/abstract.c b/Objects/abstract.c index 80a1289..503a611 100644 --- a/Objects/abstract.c +++ b/Objects/abstract.c @@ -720,8 +720,10 @@ PyObject_Format(PyObject* obj, PyObject *format_spec) static PyObject * str__format__ = NULL; PyObject *empty = NULL; PyObject *result = NULL; +#ifdef Py_USING_UNICODE int spec_is_unicode; int result_is_unicode; +#endif /* Initialize cached value */ if (str__format__ == NULL) { @@ -738,11 +740,15 @@ PyObject_Format(PyObject* obj, PyObject *format_spec) } /* Check the format_spec type, and make sure it's str or unicode */ +#if Py_USING_UNICODE if (PyUnicode_Check(format_spec)) spec_is_unicode = 1; else if (PyString_Check(format_spec)) spec_is_unicode = 0; else { +#else + if (!PyString_Check(format_spec)) { +#endif PyErr_Format(PyExc_TypeError, "format expects arg 2 to be string " "or unicode, not %.100s", Py_TYPE(format_spec)->tp_name); @@ -773,9 +779,11 @@ PyObject_Format(PyObject* obj, PyObject *format_spec) depending on the type of the format specifier). For new-style classes, this logic is done by object.__format__(). */ +#ifdef Py_USING_UNICODE if (spec_is_unicode) self_as_str = PyObject_Unicode(obj); else +#endif self_as_str = PyObject_Str(obj); if (self_as_str == NULL) goto done; @@ -818,11 +826,15 @@ PyObject_Format(PyObject* obj, PyObject *format_spec) goto done; /* Check the result type, and make sure it's str or unicode */ +#ifdef Py_USING_UNICODE if (PyUnicode_Check(result)) result_is_unicode = 1; else if (PyString_Check(result)) result_is_unicode = 0; else { +#else + if (!PyString_Check(result)) { +#endif PyErr_Format(PyExc_TypeError, "%.100s.__format__ must return string or " "unicode, not %.100s", Py_TYPE(obj)->tp_name, @@ -834,12 +846,14 @@ PyObject_Format(PyObject* obj, PyObject *format_spec) /* Convert to unicode, if needed. Required if spec is unicode and result is str */ +#ifdef Py_USING_UNICODE if (spec_is_unicode && !result_is_unicode) { PyObject *tmp = PyObject_Unicode(result); /* This logic works whether or not tmp is NULL */ Py_DECREF(result); result = tmp; } +#endif done: Py_XDECREF(empty); diff --git a/Objects/bytearrayobject.c b/Objects/bytearrayobject.c index 97b0502..4b8d585 100644 --- a/Objects/bytearrayobject.c +++ b/Objects/bytearrayobject.c @@ -803,6 +803,7 @@ bytes_init(PyByteArrayObject *self, PyObject *args, PyObject *kwds) return 0; } +#ifdef Py_USING_UNICODE if (PyUnicode_Check(arg)) { /* Encode via the codec registry */ PyObject *encoded, *new; @@ -822,6 +823,7 @@ bytes_init(PyByteArrayObject *self, PyObject *args, PyObject *kwds) Py_DECREF(new); return 0; } +#endif /* If it's not unicode, there can't be encoding or errors */ if (encoding != NULL || errors != NULL) { @@ -929,14 +931,14 @@ bytes_repr(PyByteArrayObject *self) "bytearray object is too large to make repr"); return NULL; } - v = PyUnicode_FromUnicode(NULL, newsize); + v = PyString_FromStringAndSize(NULL, newsize); if (v == NULL) { return NULL; } else { register Py_ssize_t i; - register Py_UNICODE c; - register Py_UNICODE *p; + register char c; + register char *p; int quote; /* Figure out which quote to use; single is preferred */ @@ -956,7 +958,7 @@ bytes_repr(PyByteArrayObject *self) ; } - p = PyUnicode_AS_UNICODE(v); + p = PyString_AS_STRING(v); while (*quote_prefix) *p++ = *quote_prefix++; *p++ = quote; @@ -964,7 +966,7 @@ bytes_repr(PyByteArrayObject *self) for (i = 0; i < length; i++) { /* There's at least enough room for a hex escape and a closing quote. */ - assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 5); + assert(newsize - (p - PyString_AS_STRING(v)) >= 5); c = self->ob_bytes[i]; if (c == '\'' || c == '\\') *p++ = '\\', *p++ = c; @@ -985,13 +987,13 @@ bytes_repr(PyByteArrayObject *self) else *p++ = c; } - assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 1); + assert(newsize - (p - PyString_AS_STRING(v)) >= 1); *p++ = quote; while (*quote_postfix) { *p++ = *quote_postfix++; } *p = '\0'; - if (PyUnicode_Resize(&v, (p - PyUnicode_AS_UNICODE(v)))) { + if (_PyString_Resize(&v, (p - PyString_AS_STRING(v)))) { Py_DECREF(v); return NULL; } @@ -1025,6 +1027,7 @@ bytes_richcompare(PyObject *self, PyObject *other, int op) /* Bytes can be compared to anything that supports the (binary) buffer API. Except that a comparison with Unicode is always an error, even if the comparison is for equality. */ +#ifdef Py_USING_UNICODE if (PyObject_IsInstance(self, (PyObject*)&PyUnicode_Type) || PyObject_IsInstance(other, (PyObject*)&PyUnicode_Type)) { if (Py_BytesWarningFlag && op == Py_EQ) { @@ -1036,6 +1039,7 @@ bytes_richcompare(PyObject *self, PyObject *other, int op) Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } +#endif self_size = _getbuffer(self, &self_bytes); if (self_size < 0) { @@ -2939,8 +2943,14 @@ bytes_decode(PyObject *self, PyObject *args) if (!PyArg_ParseTuple(args, "|ss:decode", &encoding, &errors)) return NULL; - if (encoding == NULL) + if (encoding == NULL) { +#ifdef Py_USING_UNICODE encoding = PyUnicode_GetDefaultEncoding(); +#else + PyErr_SetString(PyExc_ValueError, "no encoding specified"); + return NULL; +#endif + } return PyCodec_Decode(self, encoding, errors); } @@ -3038,10 +3048,8 @@ Spaces between two numbers are accepted.\n\ Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\\xb9\\x01\\xef')."); static int -hex_digit_to_int(Py_UNICODE c) +hex_digit_to_int(char c) { - if (c >= 128) - return -1; if (ISDIGIT(c)) return c - '0'; else { @@ -3056,17 +3064,14 @@ hex_digit_to_int(Py_UNICODE c) static PyObject * bytes_fromhex(PyObject *cls, PyObject *args) { - PyObject *newbytes, *hexobj; + PyObject *newbytes; char *buf; - Py_UNICODE *hex; + char *hex; Py_ssize_t hexlen, byteslen, i, j; int top, bot; - if (!PyArg_ParseTuple(args, "U:fromhex", &hexobj)) + if (!PyArg_ParseTuple(args, "s#:fromhex", &hex, &hexlen)) return NULL; - assert(PyUnicode_Check(hexobj)); - hexlen = PyUnicode_GET_SIZE(hexobj); - hex = PyUnicode_AS_UNICODE(hexobj); byteslen = hexlen/2; /* This overestimates if there are spaces */ newbytes = PyByteArray_FromStringAndSize(NULL, byteslen); if (!newbytes) @@ -3104,10 +3109,18 @@ bytes_reduce(PyByteArrayObject *self) { PyObject *latin1, *dict; if (self->ob_bytes) +#ifdef Py_USING_UNICODE latin1 = PyUnicode_DecodeLatin1(self->ob_bytes, Py_SIZE(self), NULL); +#else + latin1 = PyString_FromStringAndSize(self->ob_bytes, Py_SIZE(self)) +#endif else +#ifdef Py_USING_UNICODE latin1 = PyUnicode_FromString(""); +#else + latin1 = PyString_FromString(""); +#endif dict = PyObject_GetAttrString((PyObject *)self, "__dict__"); if (dict == NULL) { diff --git a/Objects/typeobject.c b/Objects/typeobject.c index 5e9073d..1df37d1 100644 --- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -3418,9 +3418,13 @@ object_format(PyObject *self, PyObject *args) if (!PyArg_ParseTuple(args, "O:__format__", &format_spec)) return NULL; +#ifdef Py_USING_UNICODE if (PyUnicode_Check(format_spec)) { self_as_str = PyObject_Unicode(self); } else if (PyString_Check(format_spec)) { +#else + if (PyString_Check(format_spec)) { +#endif self_as_str = PyObject_Str(self); } else { PyErr_SetString(PyExc_TypeError, "argument to __format__ must be unicode or str"); diff --git a/Python/ceval.c b/Python/ceval.c index 92a7653..4facda4 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -2933,8 +2933,11 @@ PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals, PyObject *keyword = kws[2*i]; PyObject *value = kws[2*i + 1]; int j; - if (keyword == NULL || !(PyString_Check(keyword) || - PyUnicode_Check(keyword))) { + if (keyword == NULL || !(PyString_Check(keyword) +#ifdef Py_USING_UNICODE + || PyUnicode_Check(keyword) +#endif + )) { PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", PyString_AsString(co->co_name)); @@ -3115,14 +3118,20 @@ fail: /* Jump here from prelude on failure */ } + static PyObject * kwd_as_string(PyObject *kwd) { +#ifdef Py_USING_UNICODE if (PyString_Check(kwd)) { +#else + assert(PyString_Check(kwd)); +#endif Py_INCREF(kwd); return kwd; +#ifdef Py_USING_UNICODE } - else - return _PyUnicode_AsDefaultEncodedString(kwd, "replace"); + return _PyUnicode_AsDefaultEncodedString(kwd, "replace"); +#endif } @@ -4503,7 +4512,9 @@ exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals, else if (locals == Py_None) locals = globals; if (!PyString_Check(prog) && +#ifdef Py_USING_UNICODE !PyUnicode_Check(prog) && +#endif !PyCode_Check(prog) && !PyFile_Check(prog)) { PyErr_SetString(PyExc_TypeError, diff --git a/Python/formatter_unicode.c b/Python/formatter_unicode.c index 4f2e53f..5cf5bad 100644 --- a/Python/formatter_unicode.c +++ b/Python/formatter_unicode.c @@ -2,6 +2,9 @@ built-in formatter for unicode. That is, unicode.__format__(). */ #include "Python.h" + +#ifdef Py_USING_UNICODE + #include "../Objects/stringlib/unicodedefs.h" #define FORMAT_STRING _PyUnicode_FormatAdvanced @@ -11,3 +14,5 @@ will convert them to unicode. */ #include "../Objects/stringlib/formatter.h" + +#endif -- cgit v0.12