From 339d0f720e86dc34837547c90d3003a4a68d7d46 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20v=2E=20L=C3=B6wis?= Date: Fri, 17 Aug 2001 18:39:25 +0000 Subject: Patch #445762: Support --disable-unicode - Do not compile unicodeobject, unicodectype, and unicodedata if Unicode is disabled - check for Py_USING_UNICODE in all places that use Unicode functions - disables unicode literals, and the builtin functions - add the types.StringTypes list - remove Unicode literals from most tests. --- Include/intobject.h | 2 + Include/longobject.h | 2 + Include/object.h | 2 + Include/unicodeobject.h | 7 ++++ Lib/ConfigParser.py | 4 +- Lib/copy.py | 10 ++++- Lib/site.py | 3 +- Lib/test/pickletester.py | 8 +++- Lib/test/string_tests.py | 13 ++++--- Lib/test/test_b1.py | 92 +++++++++++++++++++++++++++------------------- Lib/test/test_contains.py | 93 ++++++++++++++++++++++++----------------------- Lib/test/test_format.py | 10 +++-- Lib/test/test_iter.py | 16 +++++--- Lib/test/test_pprint.py | 11 ++++-- Lib/test/test_sre.py | 11 +++--- Lib/test/test_support.py | 13 +++++-- Lib/test/test_winreg.py | 13 ++++--- Lib/types.py | 7 +++- Makefile.pre.in | 4 +- Misc/NEWS | 18 ++++++--- Modules/_codecsmodule.c | 4 ++ Modules/_sre.c | 2 +- Modules/_tkinter.c | 11 ++++++ Modules/cPickle.c | 14 +++++++ Modules/pyexpat.c | 27 ++++++++------ Objects/abstract.c | 8 ++++ Objects/complexobject.c | 4 +- Objects/floatobject.c | 4 ++ Objects/intobject.c | 4 ++ Objects/longobject.c | 4 ++ Objects/object.c | 16 +++++++- Objects/stringobject.c | 60 ++++++++++++++++++++++++++++-- Python/bltinmodule.c | 12 ++++++ Python/compile.c | 38 ++++++++++++------- Python/getargs.c | 22 ++++++++++- Python/marshal.c | 4 ++ Python/modsupport.c | 4 ++ Python/pythonrun.c | 4 ++ Python/sysmodule.c | 10 +++++ configure | 48 +++++++++++++----------- configure.in | 3 ++ setup.py | 8 +++- 42 files changed, 465 insertions(+), 185 deletions(-) diff --git a/Include/intobject.h b/Include/intobject.h index a22d38a..128d0d3 100644 --- a/Include/intobject.h +++ b/Include/intobject.h @@ -30,7 +30,9 @@ extern DL_IMPORT(PyTypeObject) PyInt_Type; #define PyInt_Check(op) ((op)->ob_type == &PyInt_Type) extern DL_IMPORT(PyObject *) PyInt_FromString(char*, char**, int); +#ifdef Py_USING_UNICODE extern DL_IMPORT(PyObject *) PyInt_FromUnicode(Py_UNICODE*, int, int); +#endif extern DL_IMPORT(PyObject *) PyInt_FromLong(long); extern DL_IMPORT(long) PyInt_AsLong(PyObject *); extern DL_IMPORT(long) PyInt_GetMax(void); diff --git a/Include/longobject.h b/Include/longobject.h index 3c6fde0..8efa35f 100644 --- a/Include/longobject.h +++ b/Include/longobject.h @@ -42,7 +42,9 @@ extern DL_IMPORT(unsigned LONG_LONG) PyLong_AsUnsignedLongLong(PyObject *); #endif /* HAVE_LONG_LONG */ DL_IMPORT(PyObject *) PyLong_FromString(char *, char **, int); +#ifdef Py_USING_UNICODE DL_IMPORT(PyObject *) PyLong_FromUnicode(Py_UNICODE*, int, int); +#endif /* _PyLong_FromByteArray: View the n unsigned bytes as a binary integer in base 256, and return a Python long with the same numeric value. diff --git a/Include/object.h b/Include/object.h index 8da524b..f832717 100644 --- a/Include/object.h +++ b/Include/object.h @@ -320,7 +320,9 @@ extern DL_IMPORT(int) PyObject_Print(PyObject *, FILE *, int); extern DL_IMPORT(void) _PyObject_Dump(PyObject *); extern DL_IMPORT(PyObject *) PyObject_Repr(PyObject *); extern DL_IMPORT(PyObject *) PyObject_Str(PyObject *); +#ifdef Py_USING_UNICODE extern DL_IMPORT(PyObject *) PyObject_Unicode(PyObject *); +#endif extern DL_IMPORT(int) PyObject_Compare(PyObject *, PyObject *); extern DL_IMPORT(PyObject *) PyObject_RichCompare(PyObject *, PyObject *, int); extern DL_IMPORT(int) PyObject_RichCompareBool(PyObject *, PyObject *, int); diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h index a7e50c3..025c8b7 100644 --- a/Include/unicodeobject.h +++ b/Include/unicodeobject.h @@ -58,6 +58,12 @@ Copyright (c) Corporation for National Research Initiatives. /* --- Internal Unicode Format -------------------------------------------- */ +#ifndef Py_USING_UNICODE + +#define PyUnicode_Check(op) 0 + +#else + /* FIXME: MvL's new implementation assumes that Py_UNICODE_SIZE is properly set, but the default rules below doesn't set it. I'll sort this out some other day -- fredrik@pythonware.com */ @@ -1087,4 +1093,5 @@ extern DL_IMPORT(int) _PyUnicode_IsAlpha( #ifdef __cplusplus } #endif +#endif /* Py_USING_UNICODE */ #endif /* !Py_UNICODEOBJECT_H */ diff --git a/Lib/ConfigParser.py b/Lib/ConfigParser.py index 7be8ffd..fec847c 100644 --- a/Lib/ConfigParser.py +++ b/Lib/ConfigParser.py @@ -82,7 +82,7 @@ ConfigParser -- responsible for for parsing a list of write the configuration state in .ini format """ -import string +import string, types import re __all__ = ["NoSectionError","DuplicateSectionError","NoOptionError", @@ -222,7 +222,7 @@ class ConfigParser: configuration files in the list will be read. A single filename may also be given. """ - if type(filenames) in [type(''), type(u'')]: + if type(filenames) in types.StringTypes: filenames = [filenames] for filename in filenames: try: diff --git a/Lib/copy.py b/Lib/copy.py index 123162c..c8cc880 100644 --- a/Lib/copy.py +++ b/Lib/copy.py @@ -91,7 +91,10 @@ d[types.IntType] = _copy_atomic d[types.LongType] = _copy_atomic d[types.FloatType] = _copy_atomic d[types.StringType] = _copy_atomic -d[types.UnicodeType] = _copy_atomic +try: + d[types.UnicodeType] = _copy_atomic +except AttributeError: + pass try: d[types.CodeType] = _copy_atomic except AttributeError: @@ -170,7 +173,10 @@ d[types.IntType] = _deepcopy_atomic d[types.LongType] = _deepcopy_atomic d[types.FloatType] = _deepcopy_atomic d[types.StringType] = _deepcopy_atomic -d[types.UnicodeType] = _deepcopy_atomic +try: + d[types.UnicodeType] = _deepcopy_atomic +except AttributeError: + pass d[types.CodeType] = _deepcopy_atomic d[types.TypeType] = _deepcopy_atomic d[types.XRangeType] = _deepcopy_atomic diff --git a/Lib/site.py b/Lib/site.py index eaa08a7..dfe658a 100644 --- a/Lib/site.py +++ b/Lib/site.py @@ -305,7 +305,8 @@ if 0: encoding = "undefined" if encoding != "ascii": - sys.setdefaultencoding(encoding) + # On Non-Unicode builds this will raise an AttributeError... + sys.setdefaultencoding(encoding) # Needs Python Unicode build ! # # Run custom site specific code, if available. diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py index edef37c..fa3fb89 100644 --- a/Lib/test/pickletester.py +++ b/Lib/test/pickletester.py @@ -1,6 +1,6 @@ # test_pickle and test_cpickle both use this. -from test_support import TestFailed +from test_support import TestFailed, have_unicode import sys # break into multiple strings to please font-lock-mode @@ -191,7 +191,11 @@ def dotest(pickle): print "accepted insecure string: %s" % repr(buf) # Test some Unicode end cases - endcases = [u'', u'<\\u>', u'<\\\u1234>', u'<\n>', u'<\\>'] + if have_unicode: + endcases = [unicode(''), unicode('<\\u>'), unicode('<\\\u1234>'), + unicode('<\n>'), unicode('<\\>')] + else: + endcases = [] for u in endcases: try: u2 = pickle.loads(pickle.dumps(u)) diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py index 9b95a8e..e207566 100644 --- a/Lib/test/string_tests.py +++ b/Lib/test/string_tests.py @@ -1,7 +1,7 @@ """Common tests shared by test_string and test_userstring""" import string -from test_support import verify, verbose, TestFailed +from test_support import verify, verbose, TestFailed, have_unicode transtable = '\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`xyzdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377' @@ -125,11 +125,12 @@ def run_method_tests(test): test('join', ' ', 'w x y z', Sequence()) test('join', 'a', 'abc', ('abc',)) test('join', 'a', 'z', UserList(['z'])) - test('join', u'.', u'a.b.c', ['a', 'b', 'c']) - test('join', '.', u'a.b.c', [u'a', 'b', 'c']) - test('join', '.', u'a.b.c', ['a', u'b', 'c']) - test('join', '.', u'a.b.c', ['a', 'b', u'c']) - test('join', '.', TypeError, ['a', u'b', 3]) + if have_unicode: + test('join', unicode('.'), unicode('a.b.c'), ['a', 'b', 'c']) + test('join', '.', unicode('a.b.c'), [unicode('a'), 'b', 'c']) + test('join', '.', unicode('a.b.c'), ['a', unicode('b'), 'c']) + test('join', '.', unicode('a.b.c'), ['a', 'b', unicode('c')]) + test('join', '.', TypeError, ['a', unicode('b'), 3]) for i in [5, 25, 125]: test('join', '-', ((('a' * i) + '-') * i)[:-1], ['a' * i] * i) diff --git a/Lib/test/test_b1.py b/Lib/test/test_b1.py index 1103a03..18b426f 100644 --- a/Lib/test/test_b1.py +++ b/Lib/test/test_b1.py @@ -119,7 +119,9 @@ if complex(0.0, 3.14j) != -3.14+0j: raise TestFailed, 'complex(0.0, 3.14j)' if complex(0j, 3.14) != 3.14j: raise TestFailed, 'complex(0j, 3.14)' if complex(0.0, 3.14) != 3.14j: raise TestFailed, 'complex(0.0, 3.14)' if complex(" 3.14+J ") != 3.14+1j: raise TestFailed, 'complex(" 3.14+J )"' -if complex(u" 3.14+J ") != 3.14+1j: raise TestFailed, 'complex(u" 3.14+J )"' +if have_unicode: + if complex(unicode(" 3.14+J ")) != 3.14+1j: + raise TestFailed, 'complex(u" 3.14+J )"' class Z: def __complex__(self): return 3.14j z = Z() @@ -174,18 +176,20 @@ if eval('b', globals, locals) != 200: raise TestFailed, "eval(3)" if eval('c', globals, locals) != 300: raise TestFailed, "eval(4)" -if eval(u'1+1') != 2: raise TestFailed, 'eval(u\'1+1\')' -if eval(u' 1+1\n') != 2: raise TestFailed, 'eval(u\' 1+1\\n\')' +if have_unicode: + if eval(unicode('1+1')) != 2: raise TestFailed, 'eval(u\'1+1\')' + if eval(unicode(' 1+1\n')) != 2: raise TestFailed, 'eval(u\' 1+1\\n\')' globals = {'a': 1, 'b': 2} locals = {'b': 200, 'c': 300} -if eval(u'a', globals) != 1: - raise TestFailed, "eval(1) == %s" % eval(u'a', globals) -if eval(u'a', globals, locals) != 1: - raise TestFailed, "eval(2)" -if eval(u'b', globals, locals) != 200: - raise TestFailed, "eval(3)" -if eval(u'c', globals, locals) != 300: - raise TestFailed, "eval(4)" +if have_unicode: + if eval(unicode('a'), globals) != 1: + raise TestFailed, "eval(1) == %s" % eval(unicode('a'), globals) + if eval(unicode('a'), globals, locals) != 1: + raise TestFailed, "eval(2)" + if eval(unicode('b'), globals, locals) != 200: + raise TestFailed, "eval(3)" + if eval(unicode('c'), globals, locals) != 300: + raise TestFailed, "eval(4)" print 'execfile' z = 0 @@ -249,9 +253,11 @@ if float(3.14) != 3.14: raise TestFailed, 'float(3.14)' if float(314) != 314.0: raise TestFailed, 'float(314)' if float(314L) != 314.0: raise TestFailed, 'float(314L)' if float(" 3.14 ") != 3.14: raise TestFailed, 'float(" 3.14 ")' -if float(u" 3.14 ") != 3.14: raise TestFailed, 'float(u" 3.14 ")' -if float(u" \u0663.\u0661\u0664 ") != 3.14: - raise TestFailed, 'float(u" \u0663.\u0661\u0664 ")' +if have_unicode: + if float(unicode(" 3.14 ")) != 3.14: + raise TestFailed, 'float(u" 3.14 ")' + if float(unicode(" \u0663.\u0661\u0664 ")) != 3.14: + raise TestFailed, 'float(u" \u0663.\u0661\u0664 ")' print 'getattr' import sys @@ -324,7 +330,9 @@ if int(3.5) != 3: raise TestFailed, 'int(3.5)' if int(-3.5) != -3: raise TestFailed, 'int(-3.5)' # Different base: if int("10",16) != 16L: raise TestFailed, 'int("10",16)' -if int(u"10",16) != 16L: raise TestFailed, 'int(u"10",16)' +if have_unicode: + if int(unicode("10"),16) != 16L: + raise TestFailed, 'int(u"10",16)' # Test conversion from strings and various anomalies L = [ ('0', 0), @@ -343,23 +351,26 @@ L = [ (' 1\02 ', ValueError), ('', ValueError), (' ', ValueError), - (' \t\t ', ValueError), - (u'0', 0), - (u'1', 1), - (u'9', 9), - (u'10', 10), - (u'99', 99), - (u'100', 100), - (u'314', 314), - (u' 314', 314), - (u'\u0663\u0661\u0664 ', 314), - (u' \t\t 314 \t\t ', 314), - (u' 1x', ValueError), - (u' 1 ', 1), - (u' 1\02 ', ValueError), - (u'', ValueError), - (u' ', ValueError), - (u' \t\t ', ValueError), + (' \t\t ', ValueError) +] +if have_unicode: + L += [ + (unicode('0'), 0), + (unicode('1'), 1), + (unicode('9'), 9), + (unicode('10'), 10), + (unicode('99'), 99), + (unicode('100'), 100), + (unicode('314'), 314), + (unicode(' 314'), 314), + (unicode('\u0663\u0661\u0664 '), 314), + (unicode(' \t\t 314 \t\t '), 314), + (unicode(' 1x'), ValueError), + (unicode(' 1 '), 1), + (unicode(' 1\02 '), ValueError), + (unicode(''), ValueError), + (unicode(' '), ValueError), + (unicode(' \t\t '), ValueError), ] for s, v in L: for sign in "", "+", "-": @@ -460,16 +471,23 @@ if long(-3.9) != -3L: raise TestFailed, 'long(-3.9)' if long(3.5) != 3L: raise TestFailed, 'long(3.5)' if long(-3.5) != -3L: raise TestFailed, 'long(-3.5)' if long("-3") != -3L: raise TestFailed, 'long("-3")' -if long(u"-3") != -3L: raise TestFailed, 'long(u"-3")' +if have_unicode: + if long(unicode("-3")) != -3L: + raise TestFailed, 'long(u"-3")' # Different base: if long("10",16) != 16L: raise TestFailed, 'long("10",16)' -if long(u"10",16) != 16L: raise TestFailed, 'long(u"10",16)' +if have_unicode: + if long(unicode("10"),16) != 16L: + raise TestFailed, 'long(u"10",16)' # Check conversions from string (same test set as for int(), and then some) LL = [ ('1' + '0'*20, 10L**20), - ('1' + '0'*100, 10L**100), - (u'1' + u'0'*20, 10L**20), - (u'1' + u'0'*100, 10L**100), + ('1' + '0'*100, 10L**100) +] +if have_unicode: + L+=[ + (unicode('1') + unicode('0')*20, 10L**20), + (unicode('1') + unicode('0')*100, 10L**100), ] for s, v in L + LL: for sign in "", "+", "-": diff --git a/Lib/test/test_contains.py b/Lib/test/test_contains.py index 8fec425..1a9a965 100644 --- a/Lib/test/test_contains.py +++ b/Lib/test/test_contains.py @@ -1,4 +1,4 @@ -from test_support import TestFailed +from test_support import TestFailed, have_unicode class base_set: @@ -63,62 +63,65 @@ try: except TypeError: pass -# Test char in Unicode -check('c' in u'abc', "'c' not in u'abc'") -check('d' not in u'abc', "'d' in u'abc'") +if have_unicode: -try: - '' in u'abc' - check(0, "'' in u'abc' did not raise error") -except TypeError: - pass + # Test char in Unicode -try: - 'ab' in u'abc' - check(0, "'ab' in u'abc' did not raise error") -except TypeError: - pass + check('c' in unicode('abc'), "'c' not in u'abc'") + check('d' not in unicode('abc'), "'d' in u'abc'") -try: - None in u'abc' - check(0, "None in u'abc' did not raise error") -except TypeError: - pass + try: + '' in unicode('abc') + check(0, "'' in u'abc' did not raise error") + except TypeError: + pass -# Test Unicode char in Unicode + try: + 'ab' in unicode('abc') + check(0, "'ab' in u'abc' did not raise error") + except TypeError: + pass -check(u'c' in u'abc', "u'c' not in u'abc'") -check(u'd' not in u'abc', "u'd' in u'abc'") + try: + None in unicode('abc') + check(0, "None in u'abc' did not raise error") + except TypeError: + pass -try: - u'' in u'abc' - check(0, "u'' in u'abc' did not raise error") -except TypeError: - pass + # Test Unicode char in Unicode -try: - u'ab' in u'abc' - check(0, "u'ab' in u'abc' did not raise error") -except TypeError: - pass + check(unicode('c') in unicode('abc'), "u'c' not in u'abc'") + check(unicode('d') not in unicode('abc'), "u'd' in u'abc'") -# Test Unicode char in string + try: + unicode('') in unicode('abc') + check(0, "u'' in u'abc' did not raise error") + except TypeError: + pass -check(u'c' in 'abc', "u'c' not in 'abc'") -check(u'd' not in 'abc', "u'd' in 'abc'") + try: + unicode('ab') in unicode('abc') + check(0, "u'ab' in u'abc' did not raise error") + except TypeError: + pass -try: - u'' in 'abc' - check(0, "u'' in 'abc' did not raise error") -except TypeError: - pass + # Test Unicode char in string -try: - u'ab' in 'abc' - check(0, "u'ab' in 'abc' did not raise error") -except TypeError: - pass + check(unicode('c') in 'abc', "u'c' not in 'abc'") + check(unicode('d') not in 'abc', "u'd' in 'abc'") + + try: + unicode('') in 'abc' + check(0, "u'' in 'abc' did not raise error") + except TypeError: + pass + + try: + unicode('ab') in 'abc' + check(0, "u'ab' in 'abc' did not raise error") + except TypeError: + pass # A collection of tests on builtin sequence types a = range(10) diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py index c74db0f..a89ed52 100644 --- a/Lib/test/test_format.py +++ b/Lib/test/test_format.py @@ -1,4 +1,4 @@ -from test_support import verbose +from test_support import verbose, have_unicode import sys # test string formatting operator (I am not sure if this is being tested @@ -34,7 +34,8 @@ def testformat(formatstr, args, output=None): def testboth(formatstr, *args): testformat(formatstr, *args) - testformat(unicode(formatstr), *args) + if have_unicode: + testformat(unicode(formatstr), *args) testboth("%.1d", (1,), "1") @@ -212,5 +213,6 @@ def test_exc(formatstr, args, exception, excmsg): test_exc('abc %a', 1, ValueError, "unsupported format character 'a' (0x61) at index 5") -test_exc(u'abc %\u3000', 1, ValueError, - "unsupported format character '?' (0x3000) at index 5") +if have_unicode: + test_exc(unicode('abc %\u3000'), 1, ValueError, + "unsupported format character '?' (0x3000) at index 5") diff --git a/Lib/test/test_iter.py b/Lib/test/test_iter.py index 63e488e..8b6891b 100644 --- a/Lib/test/test_iter.py +++ b/Lib/test/test_iter.py @@ -1,7 +1,7 @@ # Test iterators. import unittest -from test_support import run_unittest, TESTFN, unlink +from test_support import run_unittest, TESTFN, unlink, have_unicode # Test result of triple loop (too big to inline) TRIPLETS = [(0, 0, 0), (0, 0, 1), (0, 0, 2), @@ -214,8 +214,11 @@ class TestCase(unittest.TestCase): self.check_for_loop(iter("abcde"), ["a", "b", "c", "d", "e"]) # Test a Unicode string - def test_iter_unicode(self): - self.check_for_loop(iter(u"abcde"), [u"a", u"b", u"c", u"d", u"e"]) + if have_unicode: + def test_iter_unicode(self): + self.check_for_loop(iter(unicode("abcde")), + [unicode("a"), unicode("b"), unicode("c"), + unicode("d"), unicode("e")]) # Test a directory def test_iter_dict(self): @@ -477,6 +480,7 @@ class TestCase(unittest.TestCase): d = {"one": 1, "two": 2, "three": 3} self.assertEqual(reduce(add, d), "".join(d.keys())) + # This test case will be removed if we don't have Unicode def test_unicode_join_endcase(self): # This class inserts a Unicode object into its argument's natural @@ -493,7 +497,7 @@ class TestCase(unittest.TestCase): i = self.i self.i = i+1 if i == 2: - return u"fooled you!" + return unicode("fooled you!") return self.it.next() f = open(TESTFN, "w") @@ -510,13 +514,15 @@ class TestCase(unittest.TestCase): # and pass that on to unicode.join(). try: got = " - ".join(OhPhooey(f)) - self.assertEqual(got, u"a\n - b\n - fooled you! - c\n") + self.assertEqual(got, unicode("a\n - b\n - fooled you! - c\n")) finally: f.close() try: unlink(TESTFN) except OSError: pass + if not have_unicode: + def test_unicode_join_endcase(self): pass # Test iterators with 'x in y' and 'x not in y'. def test_in_and_not_in(self): diff --git a/Lib/test/test_pprint.py b/Lib/test/test_pprint.py index ba53ee8..34c7a84 100644 --- a/Lib/test/test_pprint.py +++ b/Lib/test/test_pprint.py @@ -3,6 +3,11 @@ import unittest import test_support +try: + uni = unicode +except NameError: + def uni(x):return x + class QueryTestCase(unittest.TestCase): @@ -14,7 +19,7 @@ class QueryTestCase(unittest.TestCase): def test_basic(self): """Verify .isrecursive() and .isreadable() w/o recursion.""" verify = self.assert_ - for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, u"yaddayadda", + for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, uni("yaddayadda"), self.a, self.b): verify(not pprint.isrecursive(safe), "expected not isrecursive for " + `safe`) @@ -58,8 +63,8 @@ class QueryTestCase(unittest.TestCase): def test_same_as_repr(self): "Simple objects and small containers that should be same as repr()." verify = self.assert_ - for simple in (0, 0L, 0+0j, 0.0, "", u"", (), [], {}, verify, pprint, - -6, -6L, -6-6j, -1.5, "x", u"x", (3,), [3], {3: 6}, + for simple in (0, 0L, 0+0j, 0.0, "", uni(""), (), [], {}, verify, pprint, + -6, -6L, -6-6j, -1.5, "x", uni("x"), (3,), [3], {3: 6}, (1,2), [3,4], {5: 6, 7: 8}, {"xy\tab\n": (3,), 5: [[]], (): {}}, range(10, -11, -1) diff --git a/Lib/test/test_sre.py b/Lib/test/test_sre.py index f673c33..8442258 100644 --- a/Lib/test/test_sre.py +++ b/Lib/test/test_sre.py @@ -6,7 +6,7 @@ import sys sys.path=['.']+sys.path -from test_support import verbose, TestFailed +from test_support import verbose, TestFailed, have_unicode import sre import sys, os, string, traceback @@ -378,7 +378,8 @@ for t in tests: # Try the match with UNICODE locale enabled, and check # that it still succeeds. - obj=sre.compile(pattern, sre.UNICODE) - result=obj.search(s) - if result==None: - print '=== Fails on unicode-sensitive match', t + if have_unicode: + obj=sre.compile(pattern, sre.UNICODE) + result=obj.search(s) + if result==None: + print '=== Fails on unicode-sensitive match', t diff --git a/Lib/test/test_support.py b/Lib/test/test_support.py index 3d5c783..80b8356 100644 --- a/Lib/test/test_support.py +++ b/Lib/test/test_support.py @@ -56,6 +56,12 @@ def fcmp(x, y): # fuzzy comparison function return cmp(len(x), len(y)) return cmp(x, y) +try: + unicode + have_unicode = 1 +except NameError: + have_unicode = 0 + import os # Filename used for testing if os.name == 'java': @@ -64,9 +70,10 @@ if os.name == 'java': elif os.name != 'riscos': TESTFN = '@test' # Unicode name only used if TEST_FN_ENCODING exists for the platform. - TESTFN_UNICODE=u"@test-\xe0\xf2" # 2 latin characters. - if os.name=="nt": - TESTFN_ENCODING="mbcs" + if have_unicode: + TESTFN_UNICODE=unicode("@test-\xe0\xf2", "latin-1") # 2 latin characters. + if os.name=="nt": + TESTFN_ENCODING="mbcs" else: TESTFN = 'test' del os diff --git a/Lib/test/test_winreg.py b/Lib/test/test_winreg.py index 02bc749..ca38305 100644 --- a/Lib/test/test_winreg.py +++ b/Lib/test/test_winreg.py @@ -4,21 +4,24 @@ from _winreg import * import os, sys -from test_support import verify +from test_support import verify, have_unicode test_key_name = "SOFTWARE\\Python Registry Test Key - Delete Me" test_data = [ ("Int Value", 45, REG_DWORD), ("String Val", "A string value", REG_SZ,), - (u"Unicode Val", u"A Unicode value", REG_SZ,), ("StringExpand", "The path is %path%", REG_EXPAND_SZ), - ("UnicodeExpand", u"The path is %path%", REG_EXPAND_SZ), ("Multi-string", ["Lots", "of", "string", "values"], REG_MULTI_SZ), - ("Multi-unicode", [u"Lots", u"of", u"unicode", u"values"], REG_MULTI_SZ), - ("Multi-mixed", [u"Unicode", u"and", "string", "values"],REG_MULTI_SZ), ("Raw Data", ("binary"+chr(0)+"data"), REG_BINARY), ] +if have_unicode: + test_data+=[ + (unicode("Unicode Val"), unicode("A Unicode value"), REG_SZ,), + ("UnicodeExpand", unicode("The path is %path%"), REG_EXPAND_SZ), + ("Multi-unicode", [unicode("Lots"), unicode("of"), unicode("unicode"), unicode("values")], REG_MULTI_SZ), + ("Multi-mixed", [unicode("Unicode"), unicode("and"), "string", "values"],REG_MULTI_SZ), + ] def WriteTestData(root_key): # Set the default value for this key. diff --git a/Lib/types.py b/Lib/types.py index 01af463..6c23e24 100644 --- a/Lib/types.py +++ b/Lib/types.py @@ -19,7 +19,12 @@ except NameError: pass StringType = str -UnicodeType = unicode +try: + UnicodeType = unicode + StringTypes = [StringType, UnicodeType] +except NameError: + StringTypes = [StringType] + BufferType = type(buffer('')) TupleType = tuple diff --git a/Makefile.pre.in b/Makefile.pre.in index 10d6452..e776555 100644 --- a/Makefile.pre.in +++ b/Makefile.pre.in @@ -147,6 +147,7 @@ LIBOBJS= @LIBOBJS@ DLINCLDIR= @DLINCLDIR@ DYNLOADFILE= @DYNLOADFILE@ MACHDEP_OBJS= @MACHDEP_OBJS@ +UNICODE_OBJS= @UNICODE_OBJS@ PYTHON= python$(EXE) @@ -263,8 +264,7 @@ OBJECT_OBJS= \ Objects/stringobject.o \ Objects/tupleobject.o \ Objects/typeobject.o \ - Objects/unicodeobject.o \ - Objects/unicodectype.o + $(UNICODE_OBJS) ########################################################################## diff --git a/Misc/NEWS b/Misc/NEWS index 6bcf2e4..28f3492 100644 --- a/Misc/NEWS +++ b/Misc/NEWS @@ -1,6 +1,12 @@ What's New in Python 2.2a2? =========================== +Build + +- configure supports a new option --enable-unicode, with the values + ucs2 and ucs4 (new in 2.2a1). With --disable-unicode, the Unicode + type and supporting code is completely removed from the interpreter. + Tools - The new Tools/scripts/cleanfuture.py can be used to automatically @@ -57,6 +63,12 @@ C API sure to check the Unicode width compatibility in their extensions by using at least one of the mangled Unicode APIs in the extension. +- Two new flags METH_NOARGS and METH_O are available in method definition + tables to simplify implementation of methods with no arguments and a + single untyped argument. Calling such methods is more efficient than + calling corresponding METH_VARARGS methods. METH_OLDARGS is now + deprecated. + Windows - "import module" now compiles module.pyw if it exists and nothing else @@ -90,12 +102,6 @@ Core (These warnings currently don't conform to the warnings framework of PEP 230; we intend to fix this in 2.2a2.) -- Two new flags METH_NOARGS and METH_O are available in method definition - tables to simplify implementation of methods with no arguments and a - single untyped argument. Calling such methods is more efficient than - calling corresponding METH_VARARGS methods. METH_OLDARGS is now - deprecated. - - The UTF-16 codec was modified to be more RFC compliant. It will now only remove BOM characters at the start of the string and then only if running in native mode (UTF-16-LE and -BE won't remove a diff --git a/Modules/_codecsmodule.c b/Modules/_codecsmodule.c index 61f25d1..a085bcf 100644 --- a/Modules/_codecsmodule.c +++ b/Modules/_codecsmodule.c @@ -71,6 +71,7 @@ PyObject *codeclookup(PyObject *self, PyObject *args) return NULL; } +#ifdef Py_USING_UNICODE /* --- Helpers ------------------------------------------------------------ */ static @@ -621,12 +622,14 @@ mbcs_encode(PyObject *self, } #endif /* MS_WIN32 */ +#endif /* Py_USING_UNICODE */ /* --- Module API --------------------------------------------------------- */ static PyMethodDef _codecs_functions[] = { {"register", codecregister, 1}, {"lookup", codeclookup, 1}, +#ifdef Py_USING_UNICODE {"utf_8_encode", utf_8_encode, 1}, {"utf_8_decode", utf_8_decode, 1}, {"utf_16_encode", utf_16_encode, 1}, @@ -654,6 +657,7 @@ static PyMethodDef _codecs_functions[] = { {"mbcs_encode", mbcs_encode, 1}, {"mbcs_decode", mbcs_decode, 1}, #endif +#endif /* Py_USING_UNICODE */ {NULL, NULL} /* sentinel */ }; diff --git a/Modules/_sre.c b/Modules/_sre.c index 1776a16..9943c30 100644 --- a/Modules/_sre.c +++ b/Modules/_sre.c @@ -63,7 +63,7 @@ static char copyright[] = /* defining this one enables tracing */ #undef VERBOSE -#if PY_VERSION_HEX >= 0x01060000 +#if PY_VERSION_HEX >= 0x01060000 && defined(Py_USING_UNICODE) /* defining this enables unicode support (default under 1.6a1 and later) */ #define HAVE_UNICODE #endif diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c index 9b73307..eedb0c1 100644 --- a/Modules/_tkinter.c +++ b/Modules/_tkinter.c @@ -255,6 +255,7 @@ AsString(PyObject *value, PyObject *tmp) { if (PyString_Check(value)) return PyString_AsString(value); +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(value)) { PyObject *v = PyUnicode_AsUTF8String(value); if (v == NULL) @@ -266,6 +267,7 @@ AsString(PyObject *value, PyObject *tmp) Py_DECREF(v); return PyString_AsString(v); } +#endif else { PyObject *v = PyObject_Str(value); if (v == NULL) @@ -520,6 +522,7 @@ AsObj(PyObject *value) ckfree(FREECAST argv); return result; } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(value)) { #if TKMAJORMINOR <= 8001 /* In Tcl 8.1 we must use UTF-8 */ @@ -542,6 +545,7 @@ AsObj(PyObject *value) PyUnicode_GET_SIZE(value)); #endif /* TKMAJORMINOR > 8001 */ } +#endif else { PyObject *v = PyObject_Str(value); if (!v) @@ -616,13 +620,16 @@ Tkapp_Call(PyObject *self, PyObject *args) so would confuse applications that expect a string. */ char *s = Tcl_GetStringResult(interp); char *p = s; + /* If the result contains any bytes with the top bit set, it's UTF-8 and we should decode it to Unicode */ +#ifdef Py_USING_UNICODE while (*p != '\0') { if (*p & 0x80) break; p++; } + if (*p == '\0') res = PyString_FromStringAndSize(s, (int)(p-s)); else { @@ -634,6 +641,10 @@ Tkapp_Call(PyObject *self, PyObject *args) res = PyString_FromStringAndSize(s, (int)(p-s)); } } +#else + p = strchr(p, '\0'); + res = PyString_FromStringAndSize(s, (int)(p-s)); +#endif } LEAVE_OVERLAP_TCL diff --git a/Modules/cPickle.c b/Modules/cPickle.c index b27339f..bb0d281 100644 --- a/Modules/cPickle.c +++ b/Modules/cPickle.c @@ -1172,6 +1172,7 @@ err: } +#ifdef Py_USING_UNICODE /* A copy of PyUnicode_EncodeRawUnicodeEscape() that also translates backslash and newline characters to \uXXXX escapes. */ static PyObject * @@ -1289,6 +1290,7 @@ err: Py_XDECREF(repr); return -1; } +#endif static int @@ -1824,11 +1826,13 @@ save(Picklerobject *self, PyObject *args, int pers_save) { goto finally; } +#ifdef Py_USING_UNICODE case 'u': if ((type == &PyUnicode_Type) && (PyString_GET_SIZE(args) < 2)) { res = save_unicode(self, args, 0); goto finally; } +#endif } if (args->ob_refcnt > 1) { @@ -1857,12 +1861,14 @@ save(Picklerobject *self, PyObject *args, int pers_save) { } break; +#ifdef Py_USING_UNICODE case 'u': if (type == &PyUnicode_Type) { res = save_unicode(self, args, 1); goto finally; } break; +#endif case 't': if (type == &PyTuple_Type) { @@ -2818,6 +2824,7 @@ load_short_binstring(Unpicklerobject *self) { } +#ifdef Py_USING_UNICODE static int load_unicode(Unpicklerobject *self) { PyObject *str = 0; @@ -2836,8 +2843,10 @@ load_unicode(Unpicklerobject *self) { finally: return res; } +#endif +#ifdef Py_USING_UNICODE static int load_binunicode(Unpicklerobject *self) { PyObject *unicode; @@ -2857,6 +2866,7 @@ load_binunicode(Unpicklerobject *self) { PDATA_PUSH(self->stack, unicode, -1); return 0; } +#endif static int @@ -3615,6 +3625,7 @@ load(Unpicklerobject *self) { break; continue; +#ifdef Py_USING_UNICODE case UNICODE: if (load_unicode(self) < 0) break; @@ -3624,6 +3635,7 @@ load(Unpicklerobject *self) { if (load_binunicode(self) < 0) break; continue; +#endif case EMPTY_TUPLE: if (load_empty_tuple(self) < 0) @@ -3905,6 +3917,7 @@ noload(Unpicklerobject *self) { break; continue; +#ifdef Py_USING_UNICODE case UNICODE: if (load_unicode(self) < 0) break; @@ -3914,6 +3927,7 @@ noload(Unpicklerobject *self) { if (load_binunicode(self) < 0) break; continue; +#endif case EMPTY_TUPLE: if (load_empty_tuple(self) < 0) diff --git a/Modules/pyexpat.c b/Modules/pyexpat.c index 4bddc46..3311093 100644 --- a/Modules/pyexpat.c +++ b/Modules/pyexpat.c @@ -28,6 +28,11 @@ #define Py_TPFLAGS_GC 0 #endif +#if (PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION > 5) || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 2) +/* In Python 1.6, 2.0 and 2.1, disabling Unicode was not possible. */ +#define Py_USING_UNICODE +#endif + enum HandlerTypes { StartElement, EndElement, @@ -173,7 +178,7 @@ conv_atts_using_string(XML_Char **atts) } #endif -#if !(PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6) +#ifdef Py_USING_UNICODE #if EXPAT_VERSION == 0x010200 static PyObject * conv_atts_using_unicode(XML_Char **atts) @@ -370,7 +375,7 @@ call_with_frame(PyCodeObject *c, PyObject* func, PyObject* args) return res; } -#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 +#ifndef Py_USING_UNICODE #define STRING_CONV_FUNC conv_string_to_utf8 #else /* Python 1.6 and later versions */ @@ -506,7 +511,7 @@ VOID_HANDLER(ProcessingInstruction, const XML_Char *data), ("(O&O&)",STRING_CONV_FUNC,target, STRING_CONV_FUNC,data)) -#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 +#ifndef Py_USING_UNICODE VOID_HANDLER(CharacterData, (void *userData, const XML_Char *data, int len), ("(N)", conv_string_len_to_utf8(data,len))) @@ -531,7 +536,7 @@ VOID_HANDLER(UnparsedEntityDecl, STRING_CONV_FUNC,notationName)) #if EXPAT_VERSION >= 0x015f00 -#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 +#ifndef Py_USING_UNICODE VOID_HANDLER(EntityDecl, (void *userData, const XML_Char *entityName, @@ -608,7 +613,7 @@ conv_content_model_utf8(XML_Content * const model) return conv_content_model(model, conv_string_to_utf8); } -#if !(PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6) +#ifdef Py_USING_UNICODE static PyObject * conv_content_model_unicode(XML_Content * const model) { @@ -678,7 +683,7 @@ VOID_HANDLER(EndCdataSection, (void *userData), ("()")) -#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 +#ifndef Py_USING_UNICODE VOID_HANDLER(Default, (void *userData, const XML_Char *s, int len), ("(N)", conv_string_len_to_utf8(s,len))) @@ -1064,7 +1069,7 @@ static struct PyMethodDef xmlparse_methods[] = { /* ---------- */ -#if !(PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6) +#ifdef Py_USING_UNICODE /* pyexpat international encoding support. @@ -1158,8 +1163,7 @@ newxmlparseobject(char *encoding, char *namespace_separator) return NULL; } XML_SetUserData(self->itself, (void *)self); -#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 -#else +#ifdef Py_USING_UNICODE XML_SetUnknownEncodingHandler(self->itself, (XML_UnknownEncodingHandler) PyUnknownEncodingHandler, NULL); #endif @@ -1292,7 +1296,7 @@ xmlparse_setattr(xmlparseobject *self, char *name, PyObject *v) } if (strcmp(name, "returns_unicode") == 0) { if (PyObject_IsTrue(v)) { -#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 +#ifndef Py_USING_UNICODE PyErr_SetString(PyExc_ValueError, "Cannot return Unicode strings in Python 1.5"); return -1; @@ -1545,8 +1549,7 @@ MODULE_INITFUNC(void) info.minor, info.micro)); } #endif -#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6 -#else +#ifdef Py_USING_UNICODE init_template_buffer(); #endif /* XXX When Expat supports some way of figuring out how it was diff --git a/Objects/abstract.c b/Objects/abstract.c index b646c36..f7ade6d 100644 --- a/Objects/abstract.c +++ b/Objects/abstract.c @@ -583,8 +583,10 @@ PyNumber_Remainder(PyObject *v, PyObject *w) { if (PyString_Check(v)) return PyString_Format(v, w); +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(v)) return PyUnicode_Format(v, w); +#endif return binary_op(v, w, NB_SLOT(nb_remainder), "%"); } @@ -707,8 +709,10 @@ PyNumber_InPlaceRemainder(PyObject *v, PyObject *w) { if (PyString_Check(v)) return PyString_Format(v, w); +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(v)) return PyUnicode_Format(v, w); +#endif else return binary_iop(v, w, NB_SLOT(nb_inplace_remainder), NB_SLOT(nb_remainder), "%="); @@ -821,10 +825,12 @@ PyNumber_Int(PyObject *o) if (PyString_Check(o)) return int_from_string(PyString_AS_STRING(o), PyString_GET_SIZE(o)); +#ifdef Py_USING_UNICODE if (PyUnicode_Check(o)) return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o), PyUnicode_GET_SIZE(o), 10); +#endif m = o->ob_type->tp_as_number; if (m && m->nb_int) return m->nb_int(o); @@ -873,11 +879,13 @@ PyNumber_Long(PyObject *o) */ return long_from_string(PyString_AS_STRING(o), PyString_GET_SIZE(o)); +#ifdef Py_USING_UNICODE if (PyUnicode_Check(o)) /* The above check is done in PyLong_FromUnicode(). */ return PyLong_FromUnicode(PyUnicode_AS_UNICODE(o), PyUnicode_GET_SIZE(o), 10); +#endif m = o->ob_type->tp_as_number; if (m && m->nb_long) return m->nb_long(o); diff --git a/Objects/complexobject.c b/Objects/complexobject.c index 84eee11..cb081aa 100644 --- a/Objects/complexobject.c +++ b/Objects/complexobject.c @@ -611,14 +611,15 @@ complex_subtype_from_string(PyTypeObject *type, PyObject *v) int sw_error=0; int sign; char buffer[256]; /* For errors */ - char s_buffer[256]; int len; if (PyString_Check(v)) { s = PyString_AS_STRING(v); len = PyString_GET_SIZE(v); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(v)) { + char s_buffer[256]; if (PyUnicode_GET_SIZE(v) >= sizeof(s_buffer)) { PyErr_SetString(PyExc_ValueError, "complex() literal too large to convert"); @@ -632,6 +633,7 @@ complex_subtype_from_string(PyTypeObject *type, PyObject *v) s = s_buffer; len = (int)strlen(s); } +#endif else if (PyObject_AsCharBuffer(v, &s, &len)) { PyErr_SetString(PyExc_TypeError, "complex() arg is not a string"); diff --git a/Objects/floatobject.c b/Objects/floatobject.c index 34b252b..044d1d3 100644 --- a/Objects/floatobject.c +++ b/Objects/floatobject.c @@ -109,7 +109,9 @@ PyFloat_FromString(PyObject *v, char **pend) const char *s, *last, *end; double x; char buffer[256]; /* for errors */ +#ifdef Py_USING_UNICODE char s_buffer[256]; /* for objects convertible to a char buffer */ +#endif int len; if (pend) @@ -118,6 +120,7 @@ PyFloat_FromString(PyObject *v, char **pend) s = PyString_AS_STRING(v); len = PyString_GET_SIZE(v); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(v)) { if (PyUnicode_GET_SIZE(v) >= sizeof(s_buffer)) { PyErr_SetString(PyExc_ValueError, @@ -132,6 +135,7 @@ PyFloat_FromString(PyObject *v, char **pend) s = s_buffer; len = (int)strlen(s); } +#endif else if (PyObject_AsCharBuffer(v, &s, &len)) { PyErr_SetString(PyExc_TypeError, "float() needs a string argument"); diff --git a/Objects/intobject.c b/Objects/intobject.c index f69f81a..e7f618b 100644 --- a/Objects/intobject.c +++ b/Objects/intobject.c @@ -202,6 +202,7 @@ PyInt_FromString(char *s, char **pend, int base) return PyInt_FromLong(x); } +#ifdef Py_USING_UNICODE PyObject * PyInt_FromUnicode(Py_UNICODE *s, int length, int base) { @@ -216,6 +217,7 @@ PyInt_FromUnicode(Py_UNICODE *s, int length, int base) return NULL; return PyInt_FromString(buffer, NULL, base); } +#endif /* Methods */ @@ -765,10 +767,12 @@ int_new(PyTypeObject *type, PyObject *args, PyObject *kwds) return PyNumber_Int(x); if (PyString_Check(x)) return PyInt_FromString(PyString_AS_STRING(x), NULL, base); +#ifdef Py_USING_UNICODE if (PyUnicode_Check(x)) return PyInt_FromUnicode(PyUnicode_AS_UNICODE(x), PyUnicode_GET_SIZE(x), base); +#endif PyErr_SetString(PyExc_TypeError, "int() can't convert non-string with explicit base"); return NULL; diff --git a/Objects/longobject.c b/Objects/longobject.c index 9f7272c..01a7276 100644 --- a/Objects/longobject.c +++ b/Objects/longobject.c @@ -971,6 +971,7 @@ PyLong_FromString(char *str, char **pend, int base) return NULL; } +#ifdef Py_USING_UNICODE PyObject * PyLong_FromUnicode(Py_UNICODE *u, int length, int base) { @@ -986,6 +987,7 @@ PyLong_FromUnicode(Py_UNICODE *u, int length, int base) return PyLong_FromString(buffer, NULL, base); } +#endif /* forward */ static PyLongObject *x_divrem @@ -2054,10 +2056,12 @@ long_new(PyTypeObject *type, PyObject *args, PyObject *kwds) return PyNumber_Long(x); else if (PyString_Check(x)) return PyLong_FromString(PyString_AS_STRING(x), NULL, base); +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(x)) return PyLong_FromUnicode(PyUnicode_AS_UNICODE(x), PyUnicode_GET_SIZE(x), base); +#endif else { PyErr_SetString(PyExc_TypeError, "long() can't convert non-string with explicit base"); diff --git a/Objects/object.c b/Objects/object.c index fea9ee5..7e4a211 100644 --- a/Objects/object.c +++ b/Objects/object.c @@ -246,6 +246,7 @@ PyObject_Repr(PyObject *v) res = (*v->ob_type->tp_repr)(v); if (res == NULL) return NULL; +#ifdef Py_USING_UNICODE if (PyUnicode_Check(res)) { PyObject* str; str = PyUnicode_AsUnicodeEscapeString(res); @@ -255,6 +256,7 @@ PyObject_Repr(PyObject *v) else return NULL; } +#endif if (!PyString_Check(res)) { PyErr_Format(PyExc_TypeError, "__repr__ returned non-string (type %.200s)", @@ -283,6 +285,7 @@ PyObject_Str(PyObject *v) res = (*v->ob_type->tp_str)(v); if (res == NULL) return NULL; +#ifdef Py_USING_UNICODE if (PyUnicode_Check(res)) { PyObject* str; str = PyUnicode_AsEncodedString(res, NULL, NULL); @@ -292,6 +295,7 @@ PyObject_Str(PyObject *v) else return NULL; } +#endif if (!PyString_Check(res)) { PyErr_Format(PyExc_TypeError, "__str__ returned non-string (type %.200s)", @@ -302,6 +306,7 @@ PyObject_Str(PyObject *v) return res; } +#ifdef Py_USING_UNICODE PyObject * PyObject_Unicode(PyObject *v) { @@ -350,6 +355,7 @@ PyObject_Unicode(PyObject *v) } return res; } +#endif /* Macro to get the tp_richcompare field of a type if defined */ @@ -523,6 +529,7 @@ default_3way_compare(PyObject *v, PyObject *w) return (vv < ww) ? -1 : (vv > ww) ? 1 : 0; } +#ifdef Py_USING_UNICODE /* Special case for Unicode */ if (PyUnicode_Check(v) || PyUnicode_Check(w)) { c = PyUnicode_Compare(v, w); @@ -537,6 +544,7 @@ default_3way_compare(PyObject *v, PyObject *w) return -2; PyErr_Clear(); } +#endif /* None is smaller than anything */ if (v == Py_None) @@ -1032,6 +1040,7 @@ PyObject_GetAttr(PyObject *v, PyObject *name) { PyTypeObject *tp = v->ob_type; +#ifdef Py_USING_UNICODE /* The Unicode to string conversion is done here because the existing tp_getattro slots expect a string object as name and we wouldn't want to break those. */ @@ -1040,6 +1049,8 @@ PyObject_GetAttr(PyObject *v, PyObject *name) if (name == NULL) return NULL; } +#endif + if (!PyString_Check(name)) { PyErr_SetString(PyExc_TypeError, "attribute name must be string"); @@ -1073,6 +1084,7 @@ PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value) PyTypeObject *tp = v->ob_type; int err; +#ifdef Py_USING_UNICODE /* The Unicode to string conversion is done here because the existing tp_setattro slots expect a string object as name and we wouldn't want to break those. */ @@ -1081,7 +1093,9 @@ PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value) if (name == NULL) return -1; } - else if (!PyString_Check(name)){ + else +#endif + if (!PyString_Check(name)){ PyErr_SetString(PyExc_TypeError, "attribute name must be string"); return -1; diff --git a/Objects/stringobject.c b/Objects/stringobject.c index e2682a0..a8e063e 100644 --- a/Objects/stringobject.c +++ b/Objects/stringobject.c @@ -173,8 +173,14 @@ PyObject *PyString_AsDecodedObject(PyObject *str, goto onError; } - if (encoding == NULL) + if (encoding == NULL) { +#ifdef Py_USING_UNICODE encoding = PyUnicode_GetDefaultEncoding(); +#else + PyErr_SetString(PyExc_ValueError, "no encoding specified"); + goto onError; +#endif + } /* Decode via the codec registry */ v = PyCodec_Decode(str, encoding, errors); @@ -197,6 +203,7 @@ PyObject *PyString_AsDecodedString(PyObject *str, if (v == NULL) goto onError; +#ifdef Py_USING_UNICODE /* Convert Unicode to a string using the default encoding */ if (PyUnicode_Check(v)) { PyObject *temp = v; @@ -205,6 +212,7 @@ PyObject *PyString_AsDecodedString(PyObject *str, if (v == NULL) goto onError; } +#endif if (!PyString_Check(v)) { PyErr_Format(PyExc_TypeError, "decoder did not return a string object (type=%.400s)", @@ -245,8 +253,14 @@ PyObject *PyString_AsEncodedObject(PyObject *str, goto onError; } - if (encoding == NULL) + if (encoding == NULL) { +#ifdef Py_USING_UNICODE encoding = PyUnicode_GetDefaultEncoding(); +#else + PyErr_SetString(PyExc_ValueError, "no encoding specified"); + goto onError; +#endif + } /* Encode via the codec registry */ v = PyCodec_Encode(str, encoding, errors); @@ -269,6 +283,7 @@ PyObject *PyString_AsEncodedString(PyObject *str, if (v == NULL) goto onError; +#ifdef Py_USING_UNICODE /* Convert Unicode to a string using the default encoding */ if (PyUnicode_Check(v)) { PyObject *temp = v; @@ -277,6 +292,7 @@ PyObject *PyString_AsEncodedString(PyObject *str, if (v == NULL) goto onError; } +#endif if (!PyString_Check(v)) { PyErr_Format(PyExc_TypeError, "encoder did not return a string object (type=%.400s)", @@ -344,12 +360,15 @@ PyString_AsStringAndSize(register PyObject *obj, } if (!PyString_Check(obj)) { +#ifdef Py_USING_UNICODE if (PyUnicode_Check(obj)) { obj = _PyUnicode_AsDefaultEncodedString(obj, NULL); if (obj == NULL) return -1; } - else { + else +#endif + { PyErr_Format(PyExc_TypeError, "expected string or Unicode object, " "%.200s found", obj->ob_type->tp_name); @@ -477,8 +496,10 @@ string_concat(register PyStringObject *a, register PyObject *bb) register unsigned int size; register PyStringObject *op; if (!PyString_Check(bb)) { +#ifdef Py_USING_UNICODE if (PyUnicode_Check(bb)) return PyUnicode_Concat((PyObject *)a, bb); +#endif PyErr_Format(PyExc_TypeError, "cannot add type \"%.200s\" to string", bb->ob_type->tp_name); @@ -586,8 +607,10 @@ string_contains(PyObject *a, PyObject *el) { register char *s, *end; register char c; +#ifdef Py_USING_UNICODE if (PyUnicode_Check(el)) return PyUnicode_Contains(a, el); +#endif if (!PyString_Check(el) || PyString_Size(el) != 1) { PyErr_SetString(PyExc_TypeError, "'in ' requires character as left operand"); @@ -868,8 +891,10 @@ string_split(PyStringObject *self, PyObject *args) sub = PyString_AS_STRING(subobj); n = PyString_GET_SIZE(subobj); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(subobj)) return PyUnicode_Split((PyObject *)self, subobj, maxsplit); +#endif else if (PyObject_AsCharBuffer(subobj, &sub, &n)) return NULL; if (n == 0) { @@ -969,6 +994,7 @@ string_join(PyStringObject *self, PyObject *orig) const size_t old_sz = sz; item = PySequence_Fast_GET_ITEM(seq, i); if (!PyString_Check(item)){ +#ifdef Py_USING_UNICODE if (PyUnicode_Check(item)) { /* Defer to Unicode join. * CAUTION: There's no gurantee that the @@ -980,6 +1006,7 @@ string_join(PyStringObject *self, PyObject *orig) Py_DECREF(seq); return result; } +#endif PyErr_Format(PyExc_TypeError, "sequence item %i: expected string," " %.80s found", @@ -1046,8 +1073,10 @@ string_find_internal(PyStringObject *self, PyObject *args, int dir) sub = PyString_AS_STRING(subobj); n = PyString_GET_SIZE(subobj); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(subobj)) return PyUnicode_Find((PyObject *)self, subobj, i, last, 1); +#endif else if (PyObject_AsCharBuffer(subobj, &sub, &n)) return -2; @@ -1381,6 +1410,7 @@ string_count(PyStringObject *self, PyObject *args) sub = PyString_AS_STRING(subobj); n = PyString_GET_SIZE(subobj); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(subobj)) { int count; count = PyUnicode_Count((PyObject *)self, subobj, i, last); @@ -1389,6 +1419,7 @@ string_count(PyStringObject *self, PyObject *args) else return PyInt_FromLong((long) count); } +#endif else if (PyObject_AsCharBuffer(subobj, &sub, &n)) return NULL; @@ -1481,6 +1512,7 @@ string_translate(PyStringObject *self, PyObject *args) table1 = PyString_AS_STRING(tableobj); tablen = PyString_GET_SIZE(tableobj); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(tableobj)) { /* Unicode .translate() does not support the deletechars parameter; instead a mapping to None will cause characters @@ -1492,6 +1524,7 @@ string_translate(PyStringObject *self, PyObject *args) } return PyUnicode_Translate((PyObject *)self, tableobj, NULL); } +#endif else if (PyObject_AsCharBuffer(tableobj, &table1, &tablen)) return NULL; @@ -1500,11 +1533,13 @@ string_translate(PyStringObject *self, PyObject *args) del_table = PyString_AS_STRING(delobj); dellen = PyString_GET_SIZE(delobj); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(delobj)) { PyErr_SetString(PyExc_TypeError, "deletions are implemented differently for unicode"); return NULL; } +#endif else if (PyObject_AsCharBuffer(delobj, &del_table, &dellen)) return NULL; @@ -1729,9 +1764,11 @@ string_replace(PyStringObject *self, PyObject *args) sub = PyString_AS_STRING(subobj); sub_len = PyString_GET_SIZE(subobj); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(subobj)) return PyUnicode_Replace((PyObject *)self, subobj, replobj, count); +#endif else if (PyObject_AsCharBuffer(subobj, &sub, &sub_len)) return NULL; @@ -1739,9 +1776,11 @@ string_replace(PyStringObject *self, PyObject *args) repl = PyString_AS_STRING(replobj); repl_len = PyString_GET_SIZE(replobj); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(replobj)) return PyUnicode_Replace((PyObject *)self, subobj, replobj, count); +#endif else if (PyObject_AsCharBuffer(replobj, &repl, &repl_len)) return NULL; @@ -1792,6 +1831,7 @@ string_startswith(PyStringObject *self, PyObject *args) prefix = PyString_AS_STRING(subobj); plen = PyString_GET_SIZE(subobj); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(subobj)) { int rc; rc = PyUnicode_Tailmatch((PyObject *)self, @@ -1801,6 +1841,7 @@ string_startswith(PyStringObject *self, PyObject *args) else return PyInt_FromLong((long) rc); } +#endif else if (PyObject_AsCharBuffer(subobj, &prefix, &plen)) return NULL; @@ -1850,6 +1891,7 @@ string_endswith(PyStringObject *self, PyObject *args) suffix = PyString_AS_STRING(subobj); slen = PyString_GET_SIZE(subobj); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(subobj)) { int rc; rc = PyUnicode_Tailmatch((PyObject *)self, @@ -1859,6 +1901,7 @@ string_endswith(PyStringObject *self, PyObject *args) else return PyInt_FromLong((long) rc); } +#endif else if (PyObject_AsCharBuffer(subobj, &suffix, &slen)) return NULL; @@ -2876,7 +2919,10 @@ PyString_Format(PyObject *format, PyObject *args) char *fmt, *res; int fmtcnt, rescnt, reslen, arglen, argidx; int args_owned = 0; - PyObject *result, *orig_args, *v, *w; + PyObject *result, *orig_args; +#ifdef Py_USING_UNICODE + PyObject *v, *w; +#endif PyObject *dict = NULL; if (format == NULL || !PyString_Check(format) || args == NULL) { PyErr_BadInternalCall(); @@ -2926,8 +2972,10 @@ PyString_Format(PyObject *format, PyObject *args) int sign; int len; char formatbuf[FORMATBUFLEN]; /* For format{float,int,char}() */ +#ifdef Py_USING_UNICODE char *fmt_start = fmt; int argidx_start = argidx; +#endif fmt++; if (*fmt == '(') { @@ -3078,11 +3126,13 @@ PyString_Format(PyObject *format, PyObject *args) break; case 's': case 'r': +#ifdef Py_USING_UNICODE if (PyUnicode_Check(v)) { fmt = fmt_start; argidx = argidx_start; goto unicode; } +#endif if (c == 's') temp = PyObject_Str(v); else @@ -3240,6 +3290,7 @@ PyString_Format(PyObject *format, PyObject *args) _PyString_Resize(&result, reslen - rescnt); return result; +#ifdef Py_USING_UNICODE unicode: if (args_owned) { Py_DECREF(args); @@ -3284,6 +3335,7 @@ PyString_Format(PyObject *format, PyObject *args) Py_DECREF(v); Py_DECREF(args); return w; +#endif /* Py_USING_UNICODE */ error: Py_DECREF(result); diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c index 12af47f..d0f934f 100644 --- a/Python/bltinmodule.c +++ b/Python/bltinmodule.c @@ -276,6 +276,7 @@ static char chr_doc[] = Return a string of one character with ordinal i; 0 <= i < 256."; +#ifdef Py_USING_UNICODE static PyObject * builtin_unichr(PyObject *self, PyObject *args) { @@ -324,6 +325,7 @@ static char unichr_doc[] = "unichr(i) -> Unicode character\n\ \n\ Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff."; +#endif static PyObject * @@ -630,11 +632,13 @@ builtin_getattr(PyObject *self, PyObject *args) if (!PyArg_ParseTuple(args, "OO|O:getattr", &v, &name, &dflt)) return NULL; +#ifdef Py_USING_UNICODE if (PyUnicode_Check(name)) { name = _PyUnicode_AsDefaultEncodedString(name, NULL); if (name == NULL) return NULL; } +#endif if (!PyString_Check(name)) { PyErr_SetString(PyExc_TypeError, @@ -682,11 +686,13 @@ builtin_hasattr(PyObject *self, PyObject *args) if (!PyArg_ParseTuple(args, "OO:hasattr", &v, &name)) return NULL; +#ifdef Py_USING_UNICODE if (PyUnicode_Check(name)) { name = _PyUnicode_AsDefaultEncodedString(name, NULL); if (name == NULL) return NULL; } +#endif if (!PyString_Check(name)) { PyErr_SetString(PyExc_TypeError, @@ -1252,12 +1258,14 @@ builtin_ord(PyObject *self, PyObject* obj) ord = (long)((unsigned char)*PyString_AS_STRING(obj)); return PyInt_FromLong(ord); } +#ifdef Py_USING_UNICODE } else if (PyUnicode_Check(obj)) { size = PyUnicode_GET_SIZE(obj); if (size == 1) { ord = (long)*PyUnicode_AS_UNICODE(obj); return PyInt_FromLong(ord); } +#endif } else { PyErr_Format(PyExc_TypeError, "ord() expected string of length 1, but " \ @@ -1843,7 +1851,9 @@ static PyMethodDef builtin_methods[] = { {"round", builtin_round, METH_VARARGS, round_doc}, {"setattr", builtin_setattr, METH_VARARGS, setattr_doc}, {"slice", builtin_slice, METH_VARARGS, slice_doc}, +#ifdef Py_USING_UNICODE {"unichr", builtin_unichr, METH_VARARGS, unichr_doc}, +#endif {"vars", builtin_vars, METH_VARARGS, vars_doc}, {"xrange", builtin_xrange, METH_VARARGS, xrange_doc}, {"zip", builtin_zip, METH_VARARGS, zip_doc}, @@ -1905,9 +1915,11 @@ _PyBuiltin_Init(void) return NULL; if (PyDict_SetItemString(dict, "type", (PyObject *) &PyType_Type) < 0) return NULL; +#ifdef Py_USING_UNICODE if (PyDict_SetItemString(dict, "unicode", (PyObject *) &PyUnicode_Type) < 0) return NULL; +#endif debug = PyInt_FromLong(Py_OptimizeFlag == 0); if (PyDict_SetItemString(dict, "__debug__", debug) < 0) { Py_XDECREF(debug); diff --git a/Python/compile.c b/Python/compile.c index 21349ba..c6c3394 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -520,8 +520,8 @@ static void com_assign_name(struct compiling *, node *, int); static PyCodeObject *icompile(node *, struct compiling *); static PyCodeObject *jcompile(node *, char *, struct compiling *, PyCompilerFlags *); -static PyObject *parsestrplus(node *); -static PyObject *parsestr(char *); +static PyObject *parsestrplus(struct compiling*, node *); +static PyObject *parsestr(struct compiling *, char *); static node *get_rawdocstring(node *); static int get_ref_type(struct compiling *, char *); @@ -1111,7 +1111,7 @@ parsenumber(struct compiling *co, char *s) } static PyObject * -parsestr(char *s) +parsestr(struct compiling *com, char *s) { PyObject *v; size_t len; @@ -1122,11 +1122,19 @@ parsestr(char *s) int first = *s; int quote = first; int rawmode = 0; +#ifdef Py_USING_UNICODE int unicode = 0; +#endif if (isalpha(quote) || quote == '_') { if (quote == 'u' || quote == 'U') { +#ifdef Py_USING_UNICODE quote = *++s; unicode = 1; +#else + com_error(com, PyExc_SyntaxError, + "Unicode literals not supported in this Python"); + return NULL; +#endif } if (quote == 'r' || quote == 'R') { quote = *++s; @@ -1155,6 +1163,7 @@ parsestr(char *s) return NULL; } } +#ifdef Py_USING_UNICODE if (unicode || Py_UnicodeFlag) { if (rawmode) return PyUnicode_DecodeRawUnicodeEscape( @@ -1163,6 +1172,7 @@ parsestr(char *s) return PyUnicode_DecodeUnicodeEscape( s, len, NULL); } +#endif if (rawmode || strchr(s, '\\') == NULL) return PyString_FromStringAndSize(s, len); v = PyString_FromStringAndSize((char *)NULL, len); @@ -1238,16 +1248,16 @@ parsestr(char *s) } static PyObject * -parsestrplus(node *n) +parsestrplus(struct compiling* c, node *n) { PyObject *v; int i; REQ(CHILD(n, 0), STRING); - if ((v = parsestr(STR(CHILD(n, 0)))) != NULL) { + if ((v = parsestr(c, STR(CHILD(n, 0)))) != NULL) { /* String literal concatenation */ for (i = 1; i < NCH(n); i++) { PyObject *s; - s = parsestr(STR(CHILD(n, i))); + s = parsestr(c, STR(CHILD(n, i))); if (s == NULL) goto onError; if (PyString_Check(v) && PyString_Check(s)) { @@ -1255,6 +1265,7 @@ parsestrplus(node *n) if (v == NULL) goto onError; } +#ifdef Py_USING_UNICODE else { PyObject *temp; temp = PyUnicode_Concat(v, s); @@ -1264,6 +1275,7 @@ parsestrplus(node *n) Py_DECREF(v); v = temp; } +#endif } } return v; @@ -1445,7 +1457,7 @@ com_atom(struct compiling *c, node *n) com_push(c, 1); break; case STRING: - v = parsestrplus(n); + v = parsestrplus(c, n); if (v == NULL) { c->c_errors++; i = 255; @@ -2936,7 +2948,7 @@ is_constant_false(struct compiling *c, node *n) return i == 0; case STRING: - v = parsestr(STR(n)); + v = parsestr(c, STR(n)); if (v == NULL) { PyErr_Clear(); break; @@ -3330,7 +3342,7 @@ get_rawdocstring(node *n) } static PyObject * -get_docstring(node *n) +get_docstring(struct compiling *c, node *n) { /* Don't generate doc-strings if run with -OO */ if (Py_OptimizeFlag > 1) @@ -3338,7 +3350,7 @@ get_docstring(node *n) n = get_rawdocstring(n); if (n == NULL) return NULL; - return parsestrplus(n); + return parsestrplus(c, n); } static void @@ -3794,7 +3806,7 @@ com_file_input(struct compiling *c, node *n) int i; PyObject *doc; REQ(n, file_input); /* (NEWLINE | stmt)* ENDMARKER */ - doc = get_docstring(n); + doc = get_docstring(c, n); if (doc != NULL) { int i = com_addconst(c, doc); Py_DECREF(doc); @@ -3819,7 +3831,7 @@ compile_funcdef(struct compiling *c, node *n) node *ch; REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */ c->c_name = STR(CHILD(n, 1)); - doc = get_docstring(CHILD(n, 4)); + doc = get_docstring(c, CHILD(n, 4)); if (doc != NULL) { (void) com_addconst(c, doc); Py_DECREF(doc); @@ -3869,7 +3881,7 @@ compile_classdef(struct compiling *c, node *n) c->c_name = STR(CHILD(n, 1)); c->c_private = c->c_name; ch = CHILD(n, NCH(n)-1); /* The suite */ - doc = get_docstring(ch); + doc = get_docstring(c, ch); if (doc != NULL) { int i = com_addconst(c, doc); Py_DECREF(doc); diff --git a/Python/getargs.c b/Python/getargs.c index c9a5273..9f76ac0 100644 --- a/Python/getargs.c +++ b/Python/getargs.c @@ -566,6 +566,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) *p = PyString_AS_STRING(arg); *q = PyString_GET_SIZE(arg); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(arg)) { arg = UNICODE_DEFAULT_ENCODING(arg); if (arg == NULL) @@ -574,6 +575,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) *p = PyString_AS_STRING(arg); *q = PyString_GET_SIZE(arg); } +#endif else { /* any buffer-like object */ char *buf; int count = convertbuffer(arg, p, &buf); @@ -587,6 +589,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) if (PyString_Check(arg)) *p = PyString_AS_STRING(arg); +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(arg)) { arg = UNICODE_DEFAULT_ENCODING(arg); if (arg == NULL) @@ -594,6 +597,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) arg, msgbuf); *p = PyString_AS_STRING(arg); } +#endif else return converterr("string", arg, msgbuf); if ((int)strlen(*p) != PyString_Size(arg)) @@ -616,6 +620,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) *p = PyString_AS_STRING(arg); *q = PyString_GET_SIZE(arg); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(arg)) { arg = UNICODE_DEFAULT_ENCODING(arg); if (arg == NULL) @@ -624,6 +629,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) *p = PyString_AS_STRING(arg); *q = PyString_GET_SIZE(arg); } +#endif else { /* any buffer-like object */ char *buf; int count = convertbuffer(arg, p, &buf); @@ -640,6 +646,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) *p = 0; else if (PyString_Check(arg)) *p = PyString_AsString(arg); +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(arg)) { arg = UNICODE_DEFAULT_ENCODING(arg); if (arg == NULL) @@ -647,6 +654,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) arg, msgbuf); *p = PyString_AS_STRING(arg); } +#endif else return converterr("string or None", arg, msgbuf); @@ -670,13 +678,15 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) case 'e': {/* encoded string */ char **buffer; const char *encoding; - PyObject *u, *s; + PyObject *s; int size, recode_strings; /* Get 'e' parameter: the encoding name */ encoding = (const char *)va_arg(*p_va, const char *); +#ifdef Py_USING_UNICODE if (encoding == NULL) encoding = PyUnicode_GetDefaultEncoding(); +#endif /* Get output buffer parameter: 's' (recode all objects via Unicode) or @@ -702,6 +712,9 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) Py_INCREF(s); } else { +#ifdef Py_USING_UNICODE + PyObject *u; + /* Convert object to Unicode */ u = PyUnicode_FromObject(arg); if (u == NULL) @@ -723,6 +736,9 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) "(encoder failed to return a string)", arg, msgbuf); } +#else + return converterr("string", arg, msgbuf); +#endif } size = PyString_GET_SIZE(s); @@ -808,6 +824,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) break; } +#ifdef Py_USING_UNICODE case 'u': {/* raw unicode buffer (Py_UNICODE *) */ if (*format == '#') { /* any buffer-like object */ void **p = (void **)va_arg(*p_va, char **); @@ -829,6 +846,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) } break; } +#endif case 'S': { /* string object */ PyObject **p = va_arg(*p_va, PyObject **); @@ -839,6 +857,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) break; } +#ifdef Py_USING_UNICODE case 'U': { /* Unicode object */ PyObject **p = va_arg(*p_va, PyObject **); if (PyUnicode_Check(arg)) @@ -847,6 +866,7 @@ convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf) return converterr("unicode", arg, msgbuf); break; } +#endif case 'O': { /* object */ PyTypeObject *type; diff --git a/Python/marshal.c b/Python/marshal.c index 008659d..5ef11ef 100644 --- a/Python/marshal.c +++ b/Python/marshal.c @@ -187,6 +187,7 @@ w_object(PyObject *v, WFILE *p) w_long((long)n, p); w_string(PyString_AS_STRING(v), n, p); } +#ifdef Py_USING_UNICODE else if (PyUnicode_Check(v)) { PyObject *utf8; utf8 = PyUnicode_AsUTF8String(v); @@ -201,6 +202,7 @@ w_object(PyObject *v, WFILE *p) w_string(PyString_AS_STRING(utf8), n, p); Py_DECREF(utf8); } +#endif else if (PyTuple_Check(v)) { w_byte(TYPE_TUPLE, p); n = PyTuple_Size(v); @@ -472,6 +474,7 @@ r_object(RFILE *p) } return v; +#ifdef Py_USING_UNICODE case TYPE_UNICODE: { char *buffer; @@ -494,6 +497,7 @@ r_object(RFILE *p) PyMem_DEL(buffer); return v; } +#endif case TYPE_TUPLE: n = r_long(p); diff --git a/Python/modsupport.c b/Python/modsupport.c index 8fad54a..0450a8a 100644 --- a/Python/modsupport.c +++ b/Python/modsupport.c @@ -199,6 +199,7 @@ do_mklist(char **p_format, va_list *p_va, int endchar, int n) return v; } +#ifdef Py_USING_UNICODE static int _ustrlen(Py_UNICODE *u) { @@ -207,6 +208,7 @@ _ustrlen(Py_UNICODE *u) while (*v != 0) { i++; v++; } return i; } +#endif static PyObject * do_mktuple(char **p_format, va_list *p_va, int endchar, int n) @@ -269,6 +271,7 @@ do_mkvalue(char **p_format, va_list *p_va) case 'L': return PyLong_FromLongLong((LONG_LONG)va_arg(*p_va, LONG_LONG)); #endif +#ifdef Py_USING_UNICODE case 'u': { PyObject *v; @@ -291,6 +294,7 @@ do_mkvalue(char **p_format, va_list *p_va) } return v; } +#endif case 'f': case 'd': return PyFloat_FromDouble( diff --git a/Python/pythonrun.c b/Python/pythonrun.c index 232ba55..621ce9d 100644 --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -125,8 +125,10 @@ Py_Initialize(void) /* Init codec registry */ _PyCodecRegistry_Init(); +#ifdef Py_USING_UNICODE /* Init Unicode implementation; relies on the codec registry */ _PyUnicode_Init(); +#endif bimod = _PyBuiltin_Init(); if (bimod == NULL) @@ -206,8 +208,10 @@ Py_Finalize(void) /* Disable signal handling */ PyOS_FiniInterrupts(); +#ifdef Py_USING_UNICODE /* Cleanup Unicode implementation */ _PyUnicode_Fini(); +#endif /* Cleanup Codec registry */ _PyCodecRegistry_Fini(); diff --git a/Python/sysmodule.c b/Python/sysmodule.c index 2eae03d..82d2999 100644 --- a/Python/sysmodule.c +++ b/Python/sysmodule.c @@ -176,6 +176,8 @@ static char getdefaultencoding_doc[] = Return the current default string encoding used by the Unicode \n\ implementation."; +#ifdef Py_USING_UNICODE + static PyObject * sys_setdefaultencoding(PyObject *self, PyObject *args) { @@ -193,6 +195,8 @@ static char setdefaultencoding_doc[] = \n\ Set the current default string encoding used by the Unicode implementation."; +#endif + /* * Cached interned string objects used for calling the profile and * trace functions. Initialized by trace_init(). @@ -530,8 +534,10 @@ static PyMethodDef sys_methods[] = { {"exc_info", (PyCFunction)sys_exc_info, METH_NOARGS, exc_info_doc}, {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc}, {"exit", sys_exit, METH_OLDARGS, exit_doc}, +#ifdef Py_USING_UNICODE {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding, METH_NOARGS, getdefaultencoding_doc}, +#endif #ifdef HAVE_DLOPEN {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS, getdlopenflags_doc}, @@ -553,8 +559,10 @@ static PyMethodDef sys_methods[] = { #ifdef USE_MALLOPT {"mdebug", sys_mdebug, METH_VARARGS}, #endif +#ifdef Py_USING_UNICODE {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS, setdefaultencoding_doc}, +#endif {"setcheckinterval", sys_setcheckinterval, METH_VARARGS, setcheckinterval_doc}, #ifdef HAVE_DLOPEN @@ -782,9 +790,11 @@ _PySys_Init(void) PyDict_SetItemString(sysdict, "maxint", v = PyInt_FromLong(PyInt_GetMax())); Py_XDECREF(v); +#ifdef Py_USING_UNICODE PyDict_SetItemString(sysdict, "maxunicode", v = PyInt_FromLong(PyUnicode_GetMax())); Py_XDECREF(v); +#endif PyDict_SetItemString(sysdict, "builtin_module_names", v = list_builtin_module_names()); Py_XDECREF(v); diff --git a/configure b/configure index 0a71e8f..37e2a9d 100755 --- a/configure +++ b/configure @@ -6693,10 +6693,13 @@ EOF ;; esac + if test "$enable_unicode" = "no" then + UNICODE_OBJS="" echo "$ac_t""not used" 1>&6 else + UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o" cat >> confdefs.h <<\EOF #define Py_USING_UNICODE 1 EOF @@ -6734,14 +6737,14 @@ fi # check for endianness echo $ac_n "checking whether byte ordering is bigendian""... $ac_c" 1>&6 -echo "configure:6738: checking whether byte ordering is bigendian" >&5 +echo "configure:6741: checking whether byte ordering is bigendian" >&5 if eval "test \"`echo '$''{'ac_cv_c_bigendian'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else ac_cv_c_bigendian=unknown # See if sys/param.h defines the BYTE_ORDER macro. cat > conftest.$ac_ext < #include @@ -6752,11 +6755,11 @@ int main() { #endif ; return 0; } EOF -if { (eval echo configure:6756: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then +if { (eval echo configure:6759: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* # It does; now see whether it defined to BIG_ENDIAN or not. cat > conftest.$ac_ext < #include @@ -6767,7 +6770,7 @@ int main() { #endif ; return 0; } EOF -if { (eval echo configure:6771: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then +if { (eval echo configure:6774: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* ac_cv_c_bigendian=yes else @@ -6787,7 +6790,7 @@ if test "$cross_compiling" = yes; then { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:6807: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_c_bigendian=no else @@ -6827,7 +6830,7 @@ fi # Check whether right shifting a negative integer extends the sign bit # or fills with zeros (like the Cray J90, according to Tim Peters). echo $ac_n "checking whether right shift extends the sign bit""... $ac_c" 1>&6 -echo "configure:6831: checking whether right shift extends the sign bit" >&5 +echo "configure:6834: checking whether right shift extends the sign bit" >&5 if eval "test \"`echo '$''{'ac_cv_rshift_extends_sign'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -6836,7 +6839,7 @@ if test "$cross_compiling" = yes; then { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:6852: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_rshift_extends_sign=yes else @@ -6870,13 +6873,13 @@ fi # check for getc_unlocked and related locking functions echo $ac_n "checking for getc_unlocked() and friends""... $ac_c" 1>&6 -echo "configure:6874: checking for getc_unlocked() and friends" >&5 +echo "configure:6877: checking for getc_unlocked() and friends" >&5 if eval "test \"`echo '$''{'ac_cv_have_getc_unlocked'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < int main() { @@ -6888,7 +6891,7 @@ int main() { ; return 0; } EOF -if { (eval echo configure:6892: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:6895: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* ac_cv_have_getc_unlocked=yes else @@ -6911,7 +6914,7 @@ fi # check for readline 4.2 echo $ac_n "checking for rl_completion_matches in -lreadline""... $ac_c" 1>&6 -echo "configure:6915: checking for rl_completion_matches in -lreadline" >&5 +echo "configure:6918: checking for rl_completion_matches in -lreadline" >&5 ac_lib_var=`echo readline'_'rl_completion_matches | sed 'y%./+-%__p_%'` if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 @@ -6919,7 +6922,7 @@ else ac_save_LIBS="$LIBS" LIBS="-lreadline -ltermcap $LIBS" cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:6937: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* eval "ac_cv_lib_$ac_lib_var=yes" else @@ -6955,7 +6958,7 @@ fi echo $ac_n "checking for broken nice()""... $ac_c" 1>&6 -echo "configure:6959: checking for broken nice()" >&5 +echo "configure:6962: checking for broken nice()" >&5 if eval "test \"`echo '$''{'ac_cv_broken_nice'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -6964,7 +6967,7 @@ if test "$cross_compiling" = yes; then { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:6983: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_broken_nice=yes else @@ -7007,12 +7010,12 @@ cat >> confdefs.h <<\EOF #endif EOF echo $ac_n "checking for socklen_t""... $ac_c" 1>&6 -echo "configure:7011: checking for socklen_t" >&5 +echo "configure:7014: checking for socklen_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_socklen_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -7061,7 +7064,7 @@ done SRCDIRS="Parser Grammar Objects Python Modules" echo $ac_n "checking for build directories""... $ac_c" 1>&6 -echo "configure:7065: checking for build directories" >&5 +echo "configure:7068: checking for build directories" >&5 for dir in $SRCDIRS; do if test ! -d $dir; then mkdir $dir @@ -7252,6 +7255,7 @@ s%@HAVE_GETHOSTBYNAME_R@%$HAVE_GETHOSTBYNAME_R%g s%@HAVE_GETHOSTBYNAME@%$HAVE_GETHOSTBYNAME%g s%@LIBM@%$LIBM%g s%@LIBC@%$LIBC%g +s%@UNICODE_OBJS@%$UNICODE_OBJS%g s%@SRCDIRS@%$SRCDIRS%g CEOF diff --git a/configure.in b/configure.in index 515bc1e..329c07e 100644 --- a/configure.in +++ b/configure.in @@ -1680,10 +1680,13 @@ ucs4) unicode_size="4" ;; esac +AC_SUBST(UNICODE_OBJS) if test "$enable_unicode" = "no" then + UNICODE_OBJS="" AC_MSG_RESULT(not used) else + UNICODE_OBJS="Objects/unicodeobject.o Objects/unicodectype.o" AC_DEFINE(Py_USING_UNICODE) if test "$unicode_size" = "$ac_cv_sizeof_wchar_t" then diff --git a/setup.py b/setup.py index 8d97854..0214b1d 100644 --- a/setup.py +++ b/setup.py @@ -185,6 +185,11 @@ class PyBuildExt(build_ext): if '/usr/local/include' not in self.compiler.include_dirs: self.compiler.include_dirs.insert(0, '/usr/local/include' ) + try: + have_unicode = unicode + except NameError: + have_unicode = 0 + # lib_dirs and inc_dirs are used to search for files; # if a file is found in one of those directories, it can # be assumed that no additional -I,-L directives are needed. @@ -235,7 +240,8 @@ class PyBuildExt(build_ext): # Python C API test module exts.append( Extension('_testcapi', ['_testcapimodule.c']) ) # static Unicode character database - exts.append( Extension('unicodedata', ['unicodedata.c']) ) + if have_unicode: + exts.append( Extension('unicodedata', ['unicodedata.c']) ) # access to ISO C locale support exts.append( Extension('_locale', ['_localemodule.c']) ) -- cgit v0.12