← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Lib/xdrlib.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/xdrlib.py
 
1
"""Implements (a subset of) Sun XDR -- eXternal Data Representation.
 
2
 
 
3
See: RFC 1014
 
4
 
 
5
"""
 
6
 
 
7
import struct
 
8
try:
 
9
    from cStringIO import StringIO as _StringIO
 
10
except ImportError:
 
11
    from StringIO import StringIO as _StringIO
 
12
 
 
13
__all__ = ["Error", "Packer", "Unpacker", "ConversionError"]
 
14
 
 
15
# exceptions
 
16
class Error(Exception):
 
17
    """Exception class for this module. Use:
 
18
 
 
19
    except xdrlib.Error, var:
 
20
        # var has the Error instance for the exception
 
21
 
 
22
    Public ivars:
 
23
        msg -- contains the message
 
24
 
 
25
    """
 
26
    def __init__(self, msg):
 
27
        self.msg = msg
 
28
    def __repr__(self):
 
29
        return repr(self.msg)
 
30
    def __str__(self):
 
31
        return str(self.msg)
 
32
 
 
33
 
 
34
class ConversionError(Error):
 
35
    pass
 
36
 
 
37
 
 
38
 
 
39
class Packer:
 
40
    """Pack various data representations into a buffer."""
 
41
 
 
42
    def __init__(self):
 
43
        self.reset()
 
44
 
 
45
    def reset(self):
 
46
        self.__buf = _StringIO()
 
47
 
 
48
    def get_buffer(self):
 
49
        return self.__buf.getvalue()
 
50
    # backwards compatibility
 
51
    get_buf = get_buffer
 
52
 
 
53
    def pack_uint(self, x):
 
54
        self.__buf.write(struct.pack('>L', x))
 
55
 
 
56
    pack_int = pack_uint
 
57
    pack_enum = pack_int
 
58
 
 
59
    def pack_bool(self, x):
 
60
        if x: self.__buf.write('\0\0\0\1')
 
61
        else: self.__buf.write('\0\0\0\0')
 
62
 
 
63
    def pack_uhyper(self, x):
 
64
        self.pack_uint(x>>32 & 0xffffffffL)
 
65
        self.pack_uint(x & 0xffffffffL)
 
66
 
 
67
    pack_hyper = pack_uhyper
 
68
 
 
69
    def pack_float(self, x):
 
70
        try: self.__buf.write(struct.pack('>f', x))
 
71
        except struct.error, msg:
 
72
            raise ConversionError, msg
 
73
 
 
74
    def pack_double(self, x):
 
75
        try: self.__buf.write(struct.pack('>d', x))
 
76
        except struct.error, msg:
 
77
            raise ConversionError, msg
 
78
 
 
79
    def pack_fstring(self, n, s):
 
80
        if n < 0:
 
81
            raise ValueError, 'fstring size must be nonnegative'
 
82
        data = s[:n]
 
83
        n = ((n+3)//4)*4
 
84
        data = data + (n - len(data)) * '\0'
 
85
        self.__buf.write(data)
 
86
 
 
87
    pack_fopaque = pack_fstring
 
88
 
 
89
    def pack_string(self, s):
 
90
        n = len(s)
 
91
        self.pack_uint(n)
 
92
        self.pack_fstring(n, s)
 
93
 
 
94
    pack_opaque = pack_string
 
95
    pack_bytes = pack_string
 
96
 
 
97
    def pack_list(self, list, pack_item):
 
98
        for item in list:
 
99
            self.pack_uint(1)
 
100
            pack_item(item)
 
101
        self.pack_uint(0)
 
102
 
 
103
    def pack_farray(self, n, list, pack_item):
 
104
        if len(list) != n:
 
105
            raise ValueError, 'wrong array size'
 
106
        for item in list:
 
107
            pack_item(item)
 
108
 
 
109
    def pack_array(self, list, pack_item):
 
110
        n = len(list)
 
111
        self.pack_uint(n)
 
112
        self.pack_farray(n, list, pack_item)
 
113
 
 
114
 
 
115
 
 
116
class Unpacker:
 
117
    """Unpacks various data representations from the given buffer."""
 
118
 
 
119
    def __init__(self, data):
 
120
        self.reset(data)
 
121
 
 
122
    def reset(self, data):
 
123
        self.__buf = data
 
124
        self.__pos = 0
 
125
 
 
126
    def get_position(self):
 
127
        return self.__pos
 
128
 
 
129
    def set_position(self, position):
 
130
        self.__pos = position
 
131
 
 
132
    def get_buffer(self):
 
133
        return self.__buf
 
134
 
 
135
    def done(self):
 
136
        if self.__pos < len(self.__buf):
 
137
            raise Error('unextracted data remains')
 
138
 
 
139
    def unpack_uint(self):
 
140
        i = self.__pos
 
141
        self.__pos = j = i+4
 
142
        data = self.__buf[i:j]
 
143
        if len(data) < 4:
 
144
            raise EOFError
 
145
        x = struct.unpack('>L', data)[0]
 
146
        try:
 
147
            return int(x)
 
148
        except OverflowError:
 
149
            return x
 
150
 
 
151
    def unpack_int(self):
 
152
        i = self.__pos
 
153
        self.__pos = j = i+4
 
154
        data = self.__buf[i:j]
 
155
        if len(data) < 4:
 
156
            raise EOFError
 
157
        return struct.unpack('>l', data)[0]
 
158
 
 
159
    unpack_enum = unpack_int
 
160
 
 
161
    def unpack_bool(self):
 
162
        return bool(self.unpack_int())
 
163
 
 
164
    def unpack_uhyper(self):
 
165
        hi = self.unpack_uint()
 
166
        lo = self.unpack_uint()
 
167
        return long(hi)<<32 | lo
 
168
 
 
169
    def unpack_hyper(self):
 
170
        x = self.unpack_uhyper()
 
171
        if x >= 0x8000000000000000L:
 
172
            x = x - 0x10000000000000000L
 
173
        return x
 
174
 
 
175
    def unpack_float(self):
 
176
        i = self.__pos
 
177
        self.__pos = j = i+4
 
178
        data = self.__buf[i:j]
 
179
        if len(data) < 4:
 
180
            raise EOFError
 
181
        return struct.unpack('>f', data)[0]
 
182
 
 
183
    def unpack_double(self):
 
184
        i = self.__pos
 
185
        self.__pos = j = i+8
 
186
        data = self.__buf[i:j]
 
187
        if len(data) < 8:
 
188
            raise EOFError
 
189
        return struct.unpack('>d', data)[0]
 
190
 
 
191
    def unpack_fstring(self, n):
 
192
        if n < 0:
 
193
            raise ValueError, 'fstring size must be nonnegative'
 
194
        i = self.__pos
 
195
        j = i + (n+3)//4*4
 
196
        if j > len(self.__buf):
 
197
            raise EOFError
 
198
        self.__pos = j
 
199
        return self.__buf[i:i+n]
 
200
 
 
201
    unpack_fopaque = unpack_fstring
 
202
 
 
203
    def unpack_string(self):
 
204
        n = self.unpack_uint()
 
205
        return self.unpack_fstring(n)
 
206
 
 
207
    unpack_opaque = unpack_string
 
208
    unpack_bytes = unpack_string
 
209
 
 
210
    def unpack_list(self, unpack_item):
 
211
        list = []
 
212
        while 1:
 
213
            x = self.unpack_uint()
 
214
            if x == 0: break
 
215
            if x != 1:
 
216
                raise ConversionError, '0 or 1 expected, got %r' % (x,)
 
217
            item = unpack_item()
 
218
            list.append(item)
 
219
        return list
 
220
 
 
221
    def unpack_farray(self, n, unpack_item):
 
222
        list = []
 
223
        for i in range(n):
 
224
            list.append(unpack_item())
 
225
        return list
 
226
 
 
227
    def unpack_array(self, unpack_item):
 
228
        n = self.unpack_uint()
 
229
        return self.unpack_farray(n, unpack_item)