[pypy-svn] pypy default: Fix issue 661: accept None instead of 'strict' in most places

[arigo]

Author: Armin Rigo <arigo at tunes.org>
Branch: 
Changeset: r40144:3558359bebfa
Date: 2010-12-20 13:44 +0100
http://bitbucket.org/pypy/pypy/changeset/3558359bebfa/

Log:	Fix issue 661: accept None instead of 'strict' in most places
	in the _codecs module.

diff --git a/pypy/interpreter/test/test_gateway.py b/pypy/interpreter/test/test_gateway.py
--- a/pypy/interpreter/test/test_gateway.py
+++ b/pypy/interpreter/test/test_gateway.py
@@ -267,10 +267,12 @@
         space = self.space
         w = space.wrap
         def g3_ss(space, s0, s1):
+            if s1 is None:
+                return space.wrap(42)
             return space.wrap(s0+s1)       
         app_g3_ss = gateway.interp2app_temp(g3_ss,
                                          unwrap_spec=[gateway.ObjSpace,
-                                                      str,str])
+                                                      str, 'str_or_None'])
         w_app_g3_ss = space.wrap(app_g3_ss) 
         assert self.space.eq_w(
             space.call(w_app_g3_ss, 
@@ -280,6 +282,11 @@
         assert self.space.eq_w(
             space.call_function(w_app_g3_ss, w('foo'), w('bar')),
             w('foobar'))
+        assert self.space.eq_w(
+            space.call_function(w_app_g3_ss, w('foo'), space.w_None),
+            w(42))
+        space.raises_w(space.w_TypeError, space.call_function,
+                       w_app_g3_ss, space.w_None, w('bar'))
 
     def test_interp2app_unwrap_spec_int_float(self):
         space = self.space

diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -1126,6 +1126,11 @@
             buffer = self.buffer_w(w_obj)
             return buffer.as_str()
 
+    def str_or_None_w(self, w_obj):
+        if self.is_w(w_obj, self.w_None):
+            return None
+        return self.str_w(w_obj)
+
     def realstr_w(self, w_obj):
         # Like str_w, but only works if w_obj is really of type 'str'.
         if not self.is_true(self.isinstance(w_obj, self.w_str)):

diff --git a/pypy/module/_codecs/interp_codecs.py b/pypy/module/_codecs/interp_codecs.py
--- a/pypy/module/_codecs/interp_codecs.py
+++ b/pypy/module/_codecs/interp_codecs.py
@@ -292,7 +292,7 @@
 
 def buffer_encode(space, s, errors='strict'):
     return space.newtuple([space.wrap(s), space.wrap(len(s))])
-buffer_encode.unwrap_spec = [ObjSpace, 'bufferstr', str]
+buffer_encode.unwrap_spec = [ObjSpace, 'bufferstr', 'str_or_None']
 
 def decode(space, w_obj, w_encoding=NoneNotWrapped, errors='strict'):
     """decode(obj, [encoding[,errors]]) -> object
@@ -433,6 +433,8 @@
     make_decoder_wrapper('mbcs_decode')
 
 def utf_16_ex_decode(space, data, errors='strict', byteorder=0, w_final=False):
+    if errors is None:
+        errors = 'strict'
     final = space.is_true(w_final)
     state = space.fromcache(CodecState)
     if byteorder == 0:
@@ -448,7 +450,7 @@
         data, len(data), errors, final, state.decode_error_handler, byteorder)
     return space.newtuple([space.wrap(res), space.wrap(consumed),
                            space.wrap(byteorder)])
-utf_16_ex_decode.unwrap_spec = [ObjSpace, str, str, int, W_Root]
+utf_16_ex_decode.unwrap_spec = [ObjSpace, str, 'str_or_None', int, W_Root]
 
 # ____________________________________________________________
 # Charmap
@@ -551,8 +553,10 @@
         raise OperationError(space.w_TypeError, space.wrap("invalid mapping"))
 
 
- at unwrap_spec(ObjSpace, str, str, W_Root)
+ at unwrap_spec(ObjSpace, str, 'str_or_None', W_Root)
 def charmap_decode(space, string, errors="strict", w_mapping=None):
+    if errors is None:
+        errors = 'strict'
     if len(string) == 0:
         return space.newtuple([space.wrap(u''), space.wrap(0)])
 
@@ -568,8 +572,10 @@
         final, state.decode_error_handler, mapping)
     return space.newtuple([space.wrap(result), space.wrap(consumed)])
 
- at unwrap_spec(ObjSpace, unicode, str, W_Root)
+ at unwrap_spec(ObjSpace, unicode, 'str_or_None', W_Root)
 def charmap_encode(space, uni, errors="strict", w_mapping=None):
+    if errors is None:
+        errors = 'strict'
     if space.is_w(w_mapping, space.w_None):
         mapping = None
     else:
@@ -609,8 +615,10 @@
             return -1
         return space.int_w(w_code)
 
- at unwrap_spec(ObjSpace, 'bufferstr', str, W_Root)
+ at unwrap_spec(ObjSpace, 'bufferstr', 'str_or_None', W_Root)
 def unicode_escape_decode(space, string, errors="strict", w_final=False):
+    if errors is None:
+        errors = 'strict'
     final = space.is_true(w_final)
     state = space.fromcache(CodecState)
     errorhandler=state.decode_error_handler
@@ -627,8 +635,10 @@
 # ____________________________________________________________
 # Unicode-internal
 
- at unwrap_spec(ObjSpace, W_Root, str)
+ at unwrap_spec(ObjSpace, W_Root, 'str_or_None')
 def unicode_internal_decode(space, w_string, errors="strict"):
+    if errors is None:
+        errors = 'strict'
     # special case for this codec: unicodes are returned as is
     if space.isinstance_w(w_string, space.w_unicode):
         return space.newtuple([w_string, space.len(w_string)])
@@ -649,13 +659,13 @@
 # support for the "string escape" codec
 # This is a bytes-to bytes transformation
 
- at unwrap_spec(ObjSpace, W_Root, str)
+ at unwrap_spec(ObjSpace, W_Root, 'str_or_None')
 def escape_encode(space, w_string, errors='strict'):
     w_repr = space.repr(w_string)
     w_result = space.getslice(w_repr, space.wrap(1), space.wrap(-1))
     return space.newtuple([w_result, space.len(w_string)])
 
- at unwrap_spec(ObjSpace, str, str)
+ at unwrap_spec(ObjSpace, str, 'str_or_None')
 def escape_decode(space, data, errors='strict'):
     from pypy.interpreter.pyparser.parsestring import PyString_DecodeEscape
     result = PyString_DecodeEscape(space, data, None)

diff --git a/pypy/interpreter/gateway.py b/pypy/interpreter/gateway.py
--- a/pypy/interpreter/gateway.py
+++ b/pypy/interpreter/gateway.py
@@ -125,6 +125,9 @@
     def visit_bufferstr(self, el, app_sig):
         self.checked_space_method(el, app_sig)
 
+    def visit_str_or_None(self, el, app_sig):
+        self.checked_space_method(el, app_sig)
+
     def visit_nonnegint(self, el, app_sig):
         self.checked_space_method(el, app_sig)
 
@@ -238,6 +241,9 @@
     def visit_bufferstr(self, typ):
         self.run_args.append("space.bufferstr_w(%s)" % (self.scopenext(),))
 
+    def visit_str_or_None(self, typ):
+        self.run_args.append("space.str_or_None_w(%s)" % (self.scopenext(),))
+
     def visit_nonnegint(self, typ):
         self.run_args.append("space.nonnegint_w(%s)" % (self.scopenext(),))
 
@@ -365,6 +371,9 @@
     def visit_bufferstr(self, typ):
         self.unwrap.append("space.bufferstr_w(%s)" % (self.nextarg(),))
 
+    def visit_str_or_None(self, typ):
+        self.unwrap.append("space.str_or_None_w(%s)" % (self.nextarg(),))
+
     def visit_nonnegint(self, typ):
         self.unwrap.append("space.nonnegint_w(%s)" % (self.nextarg(),))