code.kerkeslager.com Git - sandbox/blob - serial/serial/text.py

   1 import binascii
   2 import re
   3
   4 from . import tags
   5
   6 def _make_literal_serializer(expected_value, literal):
   7     def serializer(to):
   8         assert to.instance is expected_value
   9         return literal
  10
  11     return serializer
  12
  13 def _make_integer_serializer(lower_bound, upper_bound, suffix):
  14     def _serializer(to):
  15         assert lower_bound <= to.instance and to.instance < upper_bound
  16         return '{}{}'.format(to.instance, suffix)
  17
  18     return _serializer
  19
  20 def _make_unsigned_integer_serializer(bit_length):
  21     return _make_integer_serializer(0, 2 << (bit_length - 1), 'u{}'.format(bit_length))
  22
  23 def _make_signed_integer_serializer(bit_length):
  24     upper_bound = 2 << (bit_length - 2)
  25     lower_bound = -upper_bound
  26     return _make_integer_serializer(lower_bound, upper_bound, 'i{}'.format(bit_length))
  27
  28 def _serialize_binary(to):
  29     return 'bin"{}"'.format(binascii.hexlify(to.instance).decode('ascii'))
  30
  31 _ESCAPES = {
  32     '\\': '\\\\',
  33     '"': '\\"',
  34 }
  35
  36 def _escape_character(ch):
  37     return _ESCAPES.get(ch, ch)
  38
  39 def _escape(s):
  40     return ''.join(_escape_character(ch) for ch in s)
  41
  42 def _make_string_serializer(prefix):
  43     def serializer(to):
  44         assert isinstance(to.instance, str)
  45         return '{}"{}"'.format(prefix, _escape(to.instance))
  46
  47     return serializer
  48
  49 _SERIALIZERS = {
  50     tags.NULL: _make_literal_serializer(None, 'null'),
  51     tags.TRUE: _make_literal_serializer(True, 'true'),
  52     tags.FALSE: _make_literal_serializer(False, 'false'),
  53     tags.UINT8: _make_unsigned_integer_serializer(8),
  54     tags.UINT16: _make_unsigned_integer_serializer(16),
  55     tags.UINT32: _make_unsigned_integer_serializer(32),
  56     tags.UINT64: _make_unsigned_integer_serializer(64),
  57     tags.INT8: _make_signed_integer_serializer(8),
  58     tags.INT16: _make_signed_integer_serializer(16),
  59     tags.INT32: _make_signed_integer_serializer(32),
  60     tags.INT64: _make_signed_integer_serializer(64),
  61     tags.BINARY: _serialize_binary,
  62     tags.UTF8: _make_string_serializer('utf8'),
  63     tags.UTF16: _make_string_serializer('utf16'),
  64     tags.UTF32: _make_string_serializer('utf32'),
  65 }
  66
  67 def serialize(to):
  68     return _SERIALIZERS[to.tag](to)
  69
  70 def _make_literal_deserializer(tag, instance, literal):
  71     def _deserializer(s):
  72         if s.startswith(literal):
  73             return True, tags.TaggedObject(tag = tag, instance = instance), s[len(literal):]
  74
  75         return False, None, None
  76
  77     return _deserializer
  78
  79 def _make_regex_deserializer(tag, decoder, regex):
  80     matcher = re.compile(regex).match
  81
  82     def _deserializer(s):
  83         match = matcher(s)
  84
  85         if match is None:
  86             return False, None, None
  87
  88         return True, tags.TaggedObject(tag = tag, instance = decoder(match)), s[match.end():]
  89
  90     return _deserializer
  91
  92 def _make_unsigned_int_deserializer(tag, bit_length):
  93     bound = 2 << (bit_length - 1)
  94
  95     def _decoder(match):
  96         result = int(match.group(1))
  97         assert result < bound
  98         return result
  99
 100     return _make_regex_deserializer(tag, _decoder, r'(\d+)' + 'u{}'.format(bit_length))
 101
 102 def _make_signed_int_deserializer(tag, bit_length):
 103     upper_bound = 2 << (bit_length - 2)
 104     lower_bound = -upper_bound
 105
 106     def _decoder(match):
 107         result = int(match.group(1))
 108         assert lower_bound <= result and result < upper_bound
 109         return result
 110
 111     return _make_regex_deserializer(tag, _decoder, r'(-?\d+)' + 'i{}'.format(bit_length))
 112
 113 _BINARY_MATCHER = re.compile(r'bin"([\da-f]*)"').match
 114
 115 def _deserialize_binary(s):
 116     match = _BINARY_MATCHER(s)
 117
 118     if match is None:
 119         return False, None, None
 120
 121     result = tags.TaggedObject(
 122         tag = tags.BINARY,
 123         instance = binascii.unhexlify(match.group(1)),
 124     )
 125
 126     return True, result, s[match.end():]
 127
 128 def _make_string_matcher(prefix):
 129     return re.compile(prefix + r'"(([^"]|\\.)*)"').match
 130
 131 _UNESCAPE_CHARACTERS = {
 132     '\\': '\\',
 133     '"': '"',
 134 }
 135
 136 def _unescape_character(ch):
 137     return _UNESCAPE_CHARACTERS[ch]
 138
 139 def _unescape(s):
 140     characters = []
 141     escaping = False
 142
 143     for ch in s:
 144         if escaping:
 145             characters.append(_unescape_character(ch))
 146             escaping = False
 147
 148         elif ch == '\\':
 149             escaping = True
 150
 151         else:
 152             characters.append(ch)
 153
 154     return ''.join(characters)
 155
 156 def _make_string_deserializer(tag, prefix):
 157     matcher = _make_string_matcher(prefix)
 158
 159     def deserializer(s):
 160         match = matcher(s)
 161
 162         if match is None:
 163             return False, None, None
 164
 165         result = tags.TaggedObject(
 166             tag = tag,
 167             instance = _unescape(match.group(1)),
 168         )
 169
 170         return True, result, s[match.end():]
 171
 172     return deserializer
 173
 174 _DESERIALIZERS = [
 175     _make_literal_deserializer(tags.NULL, None, 'null'),
 176     _make_literal_deserializer(tags.TRUE, True, 'true'),
 177     _make_literal_deserializer(tags.FALSE, False, 'false'),
 178     _make_unsigned_int_deserializer(tags.UINT8, 8),
 179     _make_unsigned_int_deserializer(tags.UINT16, 16),
 180     _make_unsigned_int_deserializer(tags.UINT32, 32),
 181     _make_unsigned_int_deserializer(tags.UINT64, 64),
 182     _make_signed_int_deserializer(tags.INT8, 8),
 183     _make_signed_int_deserializer(tags.INT16, 16),
 184     _make_signed_int_deserializer(tags.INT32, 32),
 185     _make_signed_int_deserializer(tags.INT64, 64),
 186     _deserialize_binary,
 187     _make_string_deserializer(tags.UTF8, 'utf8'),
 188     _make_string_deserializer(tags.UTF16, 'utf16'),
 189     _make_string_deserializer(tags.UTF32, 'utf32'),
 190 ]
 191
 192 def deserialize(s):
 193     for deserializer in _DESERIALIZERS:
 194         succeeded, result, remaining = deserializer(s)
 195
 196         if succeeded:
 197             assert remaining == ''
 198             return result
 199
 200     raise Exception()