pypy/module/binascii: bring back binascii since we have resolved all dependencies

Author: Mingshen Sun

pypy/config/pypyoption.py

@@ -34,7 +34,7 @@
     "select", "_lsprof", "signal", "_rawffi", "termios",
     "zlib", "struct", "_md5", "_sha",
     "cStringIO", "thread", "itertools", "cpyext", "array",
-    "_multiprocessing", '_warnings', "_collections",
+    "binascii", "_multiprocessing", '_warnings', "_collections",
     "_multibytecodec", "micronumpy", "_continuation", "_cffi_backend",
     "_csv", "_cppyy", "_pypyjson", "_jitlog"
 ])

pypy/module/binascii/__init__.py

@@ -0,0 +1,36 @@
+
+"""
+Mixed-module definition for the binascii module.
+Note that there is also a pure Python implementation in lib_pypy/binascii.py;
+the pypy/module/binascii/ version takes precedence if it is enabled.
+"""
+
+from pypy.interpreter.mixedmodule import MixedModule
+
+
+class Module(MixedModule):
+    """binascii - Conversion between binary data and ASCII"""
+
+    appleveldefs = {
+        }
+
+    interpleveldefs = {
+        'a2b_uu': 'interp_uu.a2b_uu',
+        'b2a_uu': 'interp_uu.b2a_uu',
+        'a2b_base64': 'interp_base64.a2b_base64',
+        'b2a_base64': 'interp_base64.b2a_base64',
+        'a2b_qp': 'interp_qp.a2b_qp',
+        'b2a_qp': 'interp_qp.b2a_qp',
+        'a2b_hqx': 'interp_hqx.a2b_hqx',
+        'b2a_hqx': 'interp_hqx.b2a_hqx',
+        'rledecode_hqx': 'interp_hqx.rledecode_hqx',
+        'rlecode_hqx': 'interp_hqx.rlecode_hqx',
+        'crc_hqx': 'interp_hqx.crc_hqx',
+        'crc32': 'interp_crc32.crc32',
+        'b2a_hex': 'interp_hexlify.hexlify',
+        'hexlify': 'interp_hexlify.hexlify',
+        'a2b_hex': 'interp_hexlify.unhexlify',
+        'unhexlify': 'interp_hexlify.unhexlify',
+        'Error'     : 'space.fromcache(interp_binascii.Cache).w_error',
+        'Incomplete': 'space.fromcache(interp_binascii.Cache).w_incomplete',
+        }

pypy/module/binascii/interp_base64.py

@@ -0,0 +1,113 @@
+from pypy.interpreter.error import OperationError
+from pypy.interpreter.gateway import unwrap_spec
+from rpython.rlib.rstring import StringBuilder
+from pypy.module.binascii.interp_binascii import raise_Error
+from rpython.rlib.rarithmetic import ovfcheck
+
+# ____________________________________________________________
+
+PAD = '='
+
+table_a2b_base64 = [
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
+    52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-1,-1, # Note PAD->-1 here
+    -1, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
+    15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
+    -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
+    41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1,
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,    
+]
+def _transform(n):
+    if n == -1:
+        return '\xff'
+    else:
+        return chr(n)
+table_a2b_base64 = ''.join(map(_transform, table_a2b_base64))
+assert len(table_a2b_base64) == 256
+
+
+@unwrap_spec(ascii='bufferstr')
+def a2b_base64(space, ascii):
+    "Decode a line of base64 data."
+
+    res = StringBuilder((len(ascii) // 4) * 3)   # maximum estimate
+    quad_pos = 0
+    leftchar = 0
+    leftbits = 0
+    last_char_was_a_pad = False
+
+    for c in ascii:
+        if c == PAD:
+            if quad_pos > 2 or (quad_pos == 2 and last_char_was_a_pad):
+                break      # stop on 'xxx=' or on 'xx=='
+            last_char_was_a_pad = True
+        else:
+            n = ord(table_a2b_base64[ord(c)])
+            if n == 0xff:
+                continue    # ignore strange characters
+            #
+            # Shift it in on the low end, and see if there's
+            # a byte ready for output.
+            quad_pos = (quad_pos + 1) & 3
+            leftchar = (leftchar << 6) | n
+            leftbits += 6
+            #
+            if leftbits >= 8:
+                leftbits -= 8
+                res.append(chr(leftchar >> leftbits))
+                leftchar &= ((1 << leftbits) - 1)
+            #
+            last_char_was_a_pad = False
+    else:
+        if leftbits != 0:
+            raise_Error(space, "Incorrect padding")
+
+    return space.newbytes(res.build())
+
+# ____________________________________________________________
+
+table_b2a_base64 = (
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
+
+@unwrap_spec(bin='bufferstr')
+def b2a_base64(space, bin):
+    "Base64-code line of data."
+
+    newlength = (len(bin) + 2) // 3
+    try:
+        newlength = ovfcheck(newlength * 4)
+    except OverflowError:
+        raise OperationError(space.w_MemoryError, space.w_None)
+    newlength += 1
+    res = StringBuilder(newlength)
+
+    leftchar = 0
+    leftbits = 0
+    for c in bin:
+        # Shift into our buffer, and output any 6bits ready
+        leftchar = (leftchar << 8) | ord(c)
+        leftbits += 8
+        res.append(table_b2a_base64[(leftchar >> (leftbits-6)) & 0x3f])
+        leftbits -= 6
+        if leftbits >= 6:
+            res.append(table_b2a_base64[(leftchar >> (leftbits-6)) & 0x3f])
+            leftbits -= 6
+    #
+    if leftbits == 2:
+        res.append(table_b2a_base64[(leftchar & 3) << 4])
+        res.append(PAD)
+        res.append(PAD)
+    elif leftbits == 4:
+        res.append(table_b2a_base64[(leftchar & 0xf) << 2])
+        res.append(PAD)
+    res.append('\n')
+    return space.newbytes(res.build())

pypy/module/binascii/interp_binascii.py

@@ -0,0 +1,14 @@
+from pypy.interpreter.error import OperationError
+
+class Cache:
+    def __init__(self, space):
+        self.w_error = space.new_exception_class("binascii.Error")
+        self.w_incomplete = space.new_exception_class("binascii.Incomplete")
+
+def raise_Error(space, msg):
+    w_error = space.fromcache(Cache).w_error
+    raise OperationError(w_error, space.newtext(msg))
+
+def raise_Incomplete(space, msg):
+    w_error = space.fromcache(Cache).w_incomplete
+    raise OperationError(w_error, space.newtext(msg))

pypy/module/binascii/interp_crc32.py

@@ -0,0 +1,12 @@
+from pypy.interpreter.gateway import unwrap_spec
+from rpython.rtyper.lltypesystem import rffi
+from rpython.rlib.rarithmetic import r_uint, intmask
+from rpython.rlib import rzipfile
+
+@unwrap_spec(data='bufferstr', oldcrc='truncatedint_w')
+def crc32(space, data, oldcrc=0):
+    "Compute the CRC-32 incrementally."
+
+    crc = rzipfile.crc32(data, r_uint(oldcrc))
+    crc = rffi.cast(rffi.INT, crc)    # unsigned => 32-bit signed
+    return space.newint(intmask(crc))

pypy/module/binascii/interp_hexlify.py

@@ -0,0 +1,56 @@
+from pypy.interpreter.error import OperationError, oefmt
+from pypy.interpreter.gateway import unwrap_spec
+from rpython.rlib.rstring import StringBuilder
+from rpython.rlib.rarithmetic import ovfcheck
+
+# ____________________________________________________________
+
+def _value2char(value):
+    if value < 10:
+        return chr(ord('0') + value)
+    else:
+        return chr((ord('a')-10) + value)
+_value2char._always_inline_ = True
+
+@unwrap_spec(data='bufferstr')
+def hexlify(space, data):
+    '''Hexadecimal representation of binary data.
+This function is also available as "hexlify()".'''
+    try:
+        newlength = ovfcheck(len(data) * 2)
+    except OverflowError:
+        raise OperationError(space.w_MemoryError, space.w_None)
+    res = StringBuilder(newlength)
+    for c in data:
+        res.append(_value2char(ord(c) >> 4))
+        res.append(_value2char(ord(c) & 0xf))
+    return space.newbytes(res.build())
+
+# ____________________________________________________________
+
+def _char2value(space, c):
+    if c <= '9':
+        if c >= '0':
+            return ord(c) - ord('0')
+    elif c <= 'F':
+        if c >= 'A':
+            return ord(c) - (ord('A')-10)
+    elif c <= 'f':
+        if c >= 'a':
+            return ord(c) - (ord('a')-10)
+    raise oefmt(space.w_TypeError, "Non-hexadecimal digit found")
+_char2value._always_inline_ = True
+
+@unwrap_spec(hexstr='bufferstr')
+def unhexlify(space, hexstr):
+    '''Binary data of hexadecimal representation.
+hexstr must contain an even number of hex digits (upper or lower case).
+This function is also available as "unhexlify()".'''
+    if len(hexstr) & 1:
+        raise oefmt(space.w_TypeError, "Odd-length string")
+    res = StringBuilder(len(hexstr) >> 1)
+    for i in range(0, len(hexstr), 2):
+        a = _char2value(space, hexstr[i])
+        b = _char2value(space, hexstr[i+1])
+        res.append(chr((a << 4) | b))
+    return space.newbytes(res.build())