Use a custom timeout in test_support.open_urlresource.
[python.git] / Lib / xdrlib.py
blob796dfafd2fff6489c0e083edd38cbcebb32eaf8d
1 """Implements (a subset of) Sun XDR -- eXternal Data Representation.
3 See: RFC 1014
5 """
7 import struct
8 try:
9 from cStringIO import StringIO as _StringIO
10 except ImportError:
11 from StringIO import StringIO as _StringIO
13 __all__ = ["Error", "Packer", "Unpacker", "ConversionError"]
15 # exceptions
16 class Error(Exception):
17 """Exception class for this module. Use:
19 except xdrlib.Error, var:
20 # var has the Error instance for the exception
22 Public ivars:
23 msg -- contains the message
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)
34 class ConversionError(Error):
35 pass
39 class Packer:
40 """Pack various data representations into a buffer."""
42 def __init__(self):
43 self.reset()
45 def reset(self):
46 self.__buf = _StringIO()
48 def get_buffer(self):
49 return self.__buf.getvalue()
50 # backwards compatibility
51 get_buf = get_buffer
53 def pack_uint(self, x):
54 self.__buf.write(struct.pack('>L', x))
56 pack_int = pack_uint
57 pack_enum = pack_int
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')
63 def pack_uhyper(self, x):
64 self.pack_uint(x>>32 & 0xffffffffL)
65 self.pack_uint(x & 0xffffffffL)
67 pack_hyper = pack_uhyper
69 def pack_float(self, x):
70 try: self.__buf.write(struct.pack('>f', x))
71 except struct.error, msg:
72 raise ConversionError, msg
74 def pack_double(self, x):
75 try: self.__buf.write(struct.pack('>d', x))
76 except struct.error, msg:
77 raise ConversionError, msg
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)
87 pack_fopaque = pack_fstring
89 def pack_string(self, s):
90 n = len(s)
91 self.pack_uint(n)
92 self.pack_fstring(n, s)
94 pack_opaque = pack_string
95 pack_bytes = pack_string
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)
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)
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)
116 class Unpacker:
117 """Unpacks various data representations from the given buffer."""
119 def __init__(self, data):
120 self.reset(data)
122 def reset(self, data):
123 self.__buf = data
124 self.__pos = 0
126 def get_position(self):
127 return self.__pos
129 def set_position(self, position):
130 self.__pos = position
132 def get_buffer(self):
133 return self.__buf
135 def done(self):
136 if self.__pos < len(self.__buf):
137 raise Error('unextracted data remains')
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
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]
159 unpack_enum = unpack_int
161 def unpack_bool(self):
162 return bool(self.unpack_int())
164 def unpack_uhyper(self):
165 hi = self.unpack_uint()
166 lo = self.unpack_uint()
167 return long(hi)<<32 | lo
169 def unpack_hyper(self):
170 x = self.unpack_uhyper()
171 if x >= 0x8000000000000000L:
172 x = x - 0x10000000000000000L
173 return x
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]
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]
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]
201 unpack_fopaque = unpack_fstring
203 def unpack_string(self):
204 n = self.unpack_uint()
205 return self.unpack_fstring(n)
207 unpack_opaque = unpack_string
208 unpack_bytes = unpack_string
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
221 def unpack_farray(self, n, unpack_item):
222 list = []
223 for i in range(n):
224 list.append(unpack_item())
225 return list
227 def unpack_array(self, unpack_item):
228 n = self.unpack_uint()
229 return self.unpack_farray(n, unpack_item)