| [2] | 1 | """Macintosh binhex compression/decompression.
|
|---|
| 2 |
|
|---|
| 3 | easy interface:
|
|---|
| 4 | binhex(inputfilename, outputfilename)
|
|---|
| 5 | hexbin(inputfilename, outputfilename)
|
|---|
| 6 | """
|
|---|
| 7 |
|
|---|
| 8 | #
|
|---|
| 9 | # Jack Jansen, CWI, August 1995.
|
|---|
| 10 | #
|
|---|
| 11 | # The module is supposed to be as compatible as possible. Especially the
|
|---|
| 12 | # easy interface should work "as expected" on any platform.
|
|---|
| 13 | # XXXX Note: currently, textfiles appear in mac-form on all platforms.
|
|---|
| 14 | # We seem to lack a simple character-translate in python.
|
|---|
| 15 | # (we should probably use ISO-Latin-1 on all but the mac platform).
|
|---|
| 16 | # XXXX The simple routines are too simple: they expect to hold the complete
|
|---|
| 17 | # files in-core. Should be fixed.
|
|---|
| 18 | # XXXX It would be nice to handle AppleDouble format on unix
|
|---|
| 19 | # (for servers serving macs).
|
|---|
| 20 | # XXXX I don't understand what happens when you get 0x90 times the same byte on
|
|---|
| 21 | # input. The resulting code (xx 90 90) would appear to be interpreted as an
|
|---|
| 22 | # escaped *value* of 0x90. All coders I've seen appear to ignore this nicety...
|
|---|
| 23 | #
|
|---|
| 24 | import sys
|
|---|
| 25 | import os
|
|---|
| 26 | import struct
|
|---|
| 27 | import binascii
|
|---|
| 28 |
|
|---|
| 29 | __all__ = ["binhex","hexbin","Error"]
|
|---|
| 30 |
|
|---|
| 31 | class Error(Exception):
|
|---|
| 32 | pass
|
|---|
| 33 |
|
|---|
| 34 | # States (what have we written)
|
|---|
| 35 | [_DID_HEADER, _DID_DATA, _DID_RSRC] = range(3)
|
|---|
| 36 |
|
|---|
| 37 | # Various constants
|
|---|
| 38 | REASONABLY_LARGE=32768 # Minimal amount we pass the rle-coder
|
|---|
| 39 | LINELEN=64
|
|---|
| 40 | RUNCHAR=chr(0x90) # run-length introducer
|
|---|
| 41 |
|
|---|
| 42 | #
|
|---|
| 43 | # This code is no longer byte-order dependent
|
|---|
| 44 |
|
|---|
| 45 | #
|
|---|
| 46 | # Workarounds for non-mac machines.
|
|---|
| 47 | try:
|
|---|
| 48 | from Carbon.File import FSSpec, FInfo
|
|---|
| 49 | from MacOS import openrf
|
|---|
| 50 |
|
|---|
| 51 | def getfileinfo(name):
|
|---|
| 52 | finfo = FSSpec(name).FSpGetFInfo()
|
|---|
| 53 | dir, file = os.path.split(name)
|
|---|
| 54 | # XXX Get resource/data sizes
|
|---|
| 55 | fp = open(name, 'rb')
|
|---|
| 56 | fp.seek(0, 2)
|
|---|
| 57 | dlen = fp.tell()
|
|---|
| 58 | fp = openrf(name, '*rb')
|
|---|
| 59 | fp.seek(0, 2)
|
|---|
| 60 | rlen = fp.tell()
|
|---|
| 61 | return file, finfo, dlen, rlen
|
|---|
| 62 |
|
|---|
| 63 | def openrsrc(name, *mode):
|
|---|
| 64 | if not mode:
|
|---|
| 65 | mode = '*rb'
|
|---|
| 66 | else:
|
|---|
| 67 | mode = '*' + mode[0]
|
|---|
| 68 | return openrf(name, mode)
|
|---|
| 69 |
|
|---|
| 70 | except ImportError:
|
|---|
| 71 | #
|
|---|
| 72 | # Glue code for non-macintosh usage
|
|---|
| 73 | #
|
|---|
| 74 |
|
|---|
| 75 | class FInfo:
|
|---|
| 76 | def __init__(self):
|
|---|
| 77 | self.Type = '????'
|
|---|
| 78 | self.Creator = '????'
|
|---|
| 79 | self.Flags = 0
|
|---|
| 80 |
|
|---|
| 81 | def getfileinfo(name):
|
|---|
| 82 | finfo = FInfo()
|
|---|
| 83 | # Quick check for textfile
|
|---|
| 84 | fp = open(name)
|
|---|
| 85 | data = open(name).read(256)
|
|---|
| 86 | for c in data:
|
|---|
| 87 | if not c.isspace() and (c<' ' or ord(c) > 0x7f):
|
|---|
| 88 | break
|
|---|
| 89 | else:
|
|---|
| 90 | finfo.Type = 'TEXT'
|
|---|
| 91 | fp.seek(0, 2)
|
|---|
| 92 | dsize = fp.tell()
|
|---|
| 93 | fp.close()
|
|---|
| 94 | dir, file = os.path.split(name)
|
|---|
| 95 | file = file.replace(':', '-', 1)
|
|---|
| 96 | return file, finfo, dsize, 0
|
|---|
| 97 |
|
|---|
| 98 | class openrsrc:
|
|---|
| 99 | def __init__(self, *args):
|
|---|
| 100 | pass
|
|---|
| 101 |
|
|---|
| 102 | def read(self, *args):
|
|---|
| 103 | return ''
|
|---|
| 104 |
|
|---|
| 105 | def write(self, *args):
|
|---|
| 106 | pass
|
|---|
| 107 |
|
|---|
| 108 | def close(self):
|
|---|
| 109 | pass
|
|---|
| 110 |
|
|---|
| 111 | class _Hqxcoderengine:
|
|---|
| 112 | """Write data to the coder in 3-byte chunks"""
|
|---|
| 113 |
|
|---|
| 114 | def __init__(self, ofp):
|
|---|
| 115 | self.ofp = ofp
|
|---|
| 116 | self.data = ''
|
|---|
| 117 | self.hqxdata = ''
|
|---|
| 118 | self.linelen = LINELEN-1
|
|---|
| 119 |
|
|---|
| 120 | def write(self, data):
|
|---|
| 121 | self.data = self.data + data
|
|---|
| 122 | datalen = len(self.data)
|
|---|
| 123 | todo = (datalen//3)*3
|
|---|
| 124 | data = self.data[:todo]
|
|---|
| 125 | self.data = self.data[todo:]
|
|---|
| 126 | if not data:
|
|---|
| 127 | return
|
|---|
| 128 | self.hqxdata = self.hqxdata + binascii.b2a_hqx(data)
|
|---|
| 129 | self._flush(0)
|
|---|
| 130 |
|
|---|
| 131 | def _flush(self, force):
|
|---|
| 132 | first = 0
|
|---|
| 133 | while first <= len(self.hqxdata)-self.linelen:
|
|---|
| 134 | last = first + self.linelen
|
|---|
| 135 | self.ofp.write(self.hqxdata[first:last]+'\n')
|
|---|
| 136 | self.linelen = LINELEN
|
|---|
| 137 | first = last
|
|---|
| 138 | self.hqxdata = self.hqxdata[first:]
|
|---|
| 139 | if force:
|
|---|
| 140 | self.ofp.write(self.hqxdata + ':\n')
|
|---|
| 141 |
|
|---|
| 142 | def close(self):
|
|---|
| 143 | if self.data:
|
|---|
| 144 | self.hqxdata = \
|
|---|
| 145 | self.hqxdata + binascii.b2a_hqx(self.data)
|
|---|
| 146 | self._flush(1)
|
|---|
| 147 | self.ofp.close()
|
|---|
| 148 | del self.ofp
|
|---|
| 149 |
|
|---|
| 150 | class _Rlecoderengine:
|
|---|
| 151 | """Write data to the RLE-coder in suitably large chunks"""
|
|---|
| 152 |
|
|---|
| 153 | def __init__(self, ofp):
|
|---|
| 154 | self.ofp = ofp
|
|---|
| 155 | self.data = ''
|
|---|
| 156 |
|
|---|
| 157 | def write(self, data):
|
|---|
| 158 | self.data = self.data + data
|
|---|
| 159 | if len(self.data) < REASONABLY_LARGE:
|
|---|
| 160 | return
|
|---|
| 161 | rledata = binascii.rlecode_hqx(self.data)
|
|---|
| 162 | self.ofp.write(rledata)
|
|---|
| 163 | self.data = ''
|
|---|
| 164 |
|
|---|
| 165 | def close(self):
|
|---|
| 166 | if self.data:
|
|---|
| 167 | rledata = binascii.rlecode_hqx(self.data)
|
|---|
| 168 | self.ofp.write(rledata)
|
|---|
| 169 | self.ofp.close()
|
|---|
| 170 | del self.ofp
|
|---|
| 171 |
|
|---|
| 172 | class BinHex:
|
|---|
| [391] | 173 | def __init__(self, name_finfo_dlen_rlen, ofp):
|
|---|
| 174 | name, finfo, dlen, rlen = name_finfo_dlen_rlen
|
|---|
| [2] | 175 | if type(ofp) == type(''):
|
|---|
| 176 | ofname = ofp
|
|---|
| 177 | ofp = open(ofname, 'w')
|
|---|
| 178 | ofp.write('(This file must be converted with BinHex 4.0)\n\n:')
|
|---|
| 179 | hqxer = _Hqxcoderengine(ofp)
|
|---|
| 180 | self.ofp = _Rlecoderengine(hqxer)
|
|---|
| 181 | self.crc = 0
|
|---|
| 182 | if finfo is None:
|
|---|
| 183 | finfo = FInfo()
|
|---|
| 184 | self.dlen = dlen
|
|---|
| 185 | self.rlen = rlen
|
|---|
| 186 | self._writeinfo(name, finfo)
|
|---|
| 187 | self.state = _DID_HEADER
|
|---|
| 188 |
|
|---|
| 189 | def _writeinfo(self, name, finfo):
|
|---|
| 190 | nl = len(name)
|
|---|
| 191 | if nl > 63:
|
|---|
| 192 | raise Error, 'Filename too long'
|
|---|
| 193 | d = chr(nl) + name + '\0'
|
|---|
| 194 | d2 = finfo.Type + finfo.Creator
|
|---|
| 195 |
|
|---|
| 196 | # Force all structs to be packed with big-endian
|
|---|
| 197 | d3 = struct.pack('>h', finfo.Flags)
|
|---|
| 198 | d4 = struct.pack('>ii', self.dlen, self.rlen)
|
|---|
| 199 | info = d + d2 + d3 + d4
|
|---|
| 200 | self._write(info)
|
|---|
| 201 | self._writecrc()
|
|---|
| 202 |
|
|---|
| 203 | def _write(self, data):
|
|---|
| 204 | self.crc = binascii.crc_hqx(data, self.crc)
|
|---|
| 205 | self.ofp.write(data)
|
|---|
| 206 |
|
|---|
| 207 | def _writecrc(self):
|
|---|
| 208 | # XXXX Should this be here??
|
|---|
| 209 | # self.crc = binascii.crc_hqx('\0\0', self.crc)
|
|---|
| 210 | if self.crc < 0:
|
|---|
| 211 | fmt = '>h'
|
|---|
| 212 | else:
|
|---|
| 213 | fmt = '>H'
|
|---|
| 214 | self.ofp.write(struct.pack(fmt, self.crc))
|
|---|
| 215 | self.crc = 0
|
|---|
| 216 |
|
|---|
| 217 | def write(self, data):
|
|---|
| 218 | if self.state != _DID_HEADER:
|
|---|
| 219 | raise Error, 'Writing data at the wrong time'
|
|---|
| 220 | self.dlen = self.dlen - len(data)
|
|---|
| 221 | self._write(data)
|
|---|
| 222 |
|
|---|
| 223 | def close_data(self):
|
|---|
| 224 | if self.dlen != 0:
|
|---|
| 225 | raise Error, 'Incorrect data size, diff=%r' % (self.rlen,)
|
|---|
| 226 | self._writecrc()
|
|---|
| 227 | self.state = _DID_DATA
|
|---|
| 228 |
|
|---|
| 229 | def write_rsrc(self, data):
|
|---|
| 230 | if self.state < _DID_DATA:
|
|---|
| 231 | self.close_data()
|
|---|
| 232 | if self.state != _DID_DATA:
|
|---|
| 233 | raise Error, 'Writing resource data at the wrong time'
|
|---|
| 234 | self.rlen = self.rlen - len(data)
|
|---|
| 235 | self._write(data)
|
|---|
| 236 |
|
|---|
| 237 | def close(self):
|
|---|
| 238 | if self.state < _DID_DATA:
|
|---|
| 239 | self.close_data()
|
|---|
| 240 | if self.state != _DID_DATA:
|
|---|
| 241 | raise Error, 'Close at the wrong time'
|
|---|
| 242 | if self.rlen != 0:
|
|---|
| 243 | raise Error, \
|
|---|
| 244 | "Incorrect resource-datasize, diff=%r" % (self.rlen,)
|
|---|
| 245 | self._writecrc()
|
|---|
| 246 | self.ofp.close()
|
|---|
| 247 | self.state = None
|
|---|
| 248 | del self.ofp
|
|---|
| 249 |
|
|---|
| 250 | def binhex(inp, out):
|
|---|
| 251 | """(infilename, outfilename) - Create binhex-encoded copy of a file"""
|
|---|
| 252 | finfo = getfileinfo(inp)
|
|---|
| 253 | ofp = BinHex(finfo, out)
|
|---|
| 254 |
|
|---|
| 255 | ifp = open(inp, 'rb')
|
|---|
| 256 | # XXXX Do textfile translation on non-mac systems
|
|---|
| 257 | while 1:
|
|---|
| 258 | d = ifp.read(128000)
|
|---|
| 259 | if not d: break
|
|---|
| 260 | ofp.write(d)
|
|---|
| 261 | ofp.close_data()
|
|---|
| 262 | ifp.close()
|
|---|
| 263 |
|
|---|
| 264 | ifp = openrsrc(inp, 'rb')
|
|---|
| 265 | while 1:
|
|---|
| 266 | d = ifp.read(128000)
|
|---|
| 267 | if not d: break
|
|---|
| 268 | ofp.write_rsrc(d)
|
|---|
| 269 | ofp.close()
|
|---|
| 270 | ifp.close()
|
|---|
| 271 |
|
|---|
| 272 | class _Hqxdecoderengine:
|
|---|
| 273 | """Read data via the decoder in 4-byte chunks"""
|
|---|
| 274 |
|
|---|
| 275 | def __init__(self, ifp):
|
|---|
| 276 | self.ifp = ifp
|
|---|
| 277 | self.eof = 0
|
|---|
| 278 |
|
|---|
| 279 | def read(self, totalwtd):
|
|---|
| 280 | """Read at least wtd bytes (or until EOF)"""
|
|---|
| 281 | decdata = ''
|
|---|
| 282 | wtd = totalwtd
|
|---|
| 283 | #
|
|---|
| 284 | # The loop here is convoluted, since we don't really now how
|
|---|
| 285 | # much to decode: there may be newlines in the incoming data.
|
|---|
| 286 | while wtd > 0:
|
|---|
| 287 | if self.eof: return decdata
|
|---|
| 288 | wtd = ((wtd+2)//3)*4
|
|---|
| 289 | data = self.ifp.read(wtd)
|
|---|
| 290 | #
|
|---|
| 291 | # Next problem: there may not be a complete number of
|
|---|
| 292 | # bytes in what we pass to a2b. Solve by yet another
|
|---|
| 293 | # loop.
|
|---|
| 294 | #
|
|---|
| 295 | while 1:
|
|---|
| 296 | try:
|
|---|
| 297 | decdatacur, self.eof = \
|
|---|
| 298 | binascii.a2b_hqx(data)
|
|---|
| 299 | break
|
|---|
| 300 | except binascii.Incomplete:
|
|---|
| 301 | pass
|
|---|
| 302 | newdata = self.ifp.read(1)
|
|---|
| 303 | if not newdata:
|
|---|
| 304 | raise Error, \
|
|---|
| 305 | 'Premature EOF on binhex file'
|
|---|
| 306 | data = data + newdata
|
|---|
| 307 | decdata = decdata + decdatacur
|
|---|
| 308 | wtd = totalwtd - len(decdata)
|
|---|
| 309 | if not decdata and not self.eof:
|
|---|
| 310 | raise Error, 'Premature EOF on binhex file'
|
|---|
| 311 | return decdata
|
|---|
| 312 |
|
|---|
| 313 | def close(self):
|
|---|
| 314 | self.ifp.close()
|
|---|
| 315 |
|
|---|
| 316 | class _Rledecoderengine:
|
|---|
| 317 | """Read data via the RLE-coder"""
|
|---|
| 318 |
|
|---|
| 319 | def __init__(self, ifp):
|
|---|
| 320 | self.ifp = ifp
|
|---|
| 321 | self.pre_buffer = ''
|
|---|
| 322 | self.post_buffer = ''
|
|---|
| 323 | self.eof = 0
|
|---|
| 324 |
|
|---|
| 325 | def read(self, wtd):
|
|---|
| 326 | if wtd > len(self.post_buffer):
|
|---|
| 327 | self._fill(wtd-len(self.post_buffer))
|
|---|
| 328 | rv = self.post_buffer[:wtd]
|
|---|
| 329 | self.post_buffer = self.post_buffer[wtd:]
|
|---|
| 330 | return rv
|
|---|
| 331 |
|
|---|
| 332 | def _fill(self, wtd):
|
|---|
| 333 | self.pre_buffer = self.pre_buffer + self.ifp.read(wtd+4)
|
|---|
| 334 | if self.ifp.eof:
|
|---|
| 335 | self.post_buffer = self.post_buffer + \
|
|---|
| 336 | binascii.rledecode_hqx(self.pre_buffer)
|
|---|
| 337 | self.pre_buffer = ''
|
|---|
| 338 | return
|
|---|
| 339 |
|
|---|
| 340 | #
|
|---|
| 341 | # Obfuscated code ahead. We have to take care that we don't
|
|---|
| 342 | # end up with an orphaned RUNCHAR later on. So, we keep a couple
|
|---|
| 343 | # of bytes in the buffer, depending on what the end of
|
|---|
| 344 | # the buffer looks like:
|
|---|
| 345 | # '\220\0\220' - Keep 3 bytes: repeated \220 (escaped as \220\0)
|
|---|
| 346 | # '?\220' - Keep 2 bytes: repeated something-else
|
|---|
| 347 | # '\220\0' - Escaped \220: Keep 2 bytes.
|
|---|
| 348 | # '?\220?' - Complete repeat sequence: decode all
|
|---|
| 349 | # otherwise: keep 1 byte.
|
|---|
| 350 | #
|
|---|
| 351 | mark = len(self.pre_buffer)
|
|---|
| 352 | if self.pre_buffer[-3:] == RUNCHAR + '\0' + RUNCHAR:
|
|---|
| 353 | mark = mark - 3
|
|---|
| 354 | elif self.pre_buffer[-1] == RUNCHAR:
|
|---|
| 355 | mark = mark - 2
|
|---|
| 356 | elif self.pre_buffer[-2:] == RUNCHAR + '\0':
|
|---|
| 357 | mark = mark - 2
|
|---|
| 358 | elif self.pre_buffer[-2] == RUNCHAR:
|
|---|
| 359 | pass # Decode all
|
|---|
| 360 | else:
|
|---|
| 361 | mark = mark - 1
|
|---|
| 362 |
|
|---|
| 363 | self.post_buffer = self.post_buffer + \
|
|---|
| 364 | binascii.rledecode_hqx(self.pre_buffer[:mark])
|
|---|
| 365 | self.pre_buffer = self.pre_buffer[mark:]
|
|---|
| 366 |
|
|---|
| 367 | def close(self):
|
|---|
| 368 | self.ifp.close()
|
|---|
| 369 |
|
|---|
| 370 | class HexBin:
|
|---|
| 371 | def __init__(self, ifp):
|
|---|
| 372 | if type(ifp) == type(''):
|
|---|
| 373 | ifp = open(ifp)
|
|---|
| 374 | #
|
|---|
| 375 | # Find initial colon.
|
|---|
| 376 | #
|
|---|
| 377 | while 1:
|
|---|
| 378 | ch = ifp.read(1)
|
|---|
| 379 | if not ch:
|
|---|
| 380 | raise Error, "No binhex data found"
|
|---|
| 381 | # Cater for \r\n terminated lines (which show up as \n\r, hence
|
|---|
| 382 | # all lines start with \r)
|
|---|
| 383 | if ch == '\r':
|
|---|
| 384 | continue
|
|---|
| 385 | if ch == ':':
|
|---|
| 386 | break
|
|---|
| 387 | if ch != '\n':
|
|---|
| 388 | dummy = ifp.readline()
|
|---|
| 389 |
|
|---|
| 390 | hqxifp = _Hqxdecoderengine(ifp)
|
|---|
| 391 | self.ifp = _Rledecoderengine(hqxifp)
|
|---|
| 392 | self.crc = 0
|
|---|
| 393 | self._readheader()
|
|---|
| 394 |
|
|---|
| 395 | def _read(self, len):
|
|---|
| 396 | data = self.ifp.read(len)
|
|---|
| 397 | self.crc = binascii.crc_hqx(data, self.crc)
|
|---|
| 398 | return data
|
|---|
| 399 |
|
|---|
| 400 | def _checkcrc(self):
|
|---|
| 401 | filecrc = struct.unpack('>h', self.ifp.read(2))[0] & 0xffff
|
|---|
| 402 | #self.crc = binascii.crc_hqx('\0\0', self.crc)
|
|---|
| 403 | # XXXX Is this needed??
|
|---|
| 404 | self.crc = self.crc & 0xffff
|
|---|
| 405 | if filecrc != self.crc:
|
|---|
| 406 | raise Error, 'CRC error, computed %x, read %x' \
|
|---|
| 407 | %(self.crc, filecrc)
|
|---|
| 408 | self.crc = 0
|
|---|
| 409 |
|
|---|
| 410 | def _readheader(self):
|
|---|
| 411 | len = self._read(1)
|
|---|
| 412 | fname = self._read(ord(len))
|
|---|
| 413 | rest = self._read(1+4+4+2+4+4)
|
|---|
| 414 | self._checkcrc()
|
|---|
| 415 |
|
|---|
| 416 | type = rest[1:5]
|
|---|
| 417 | creator = rest[5:9]
|
|---|
| 418 | flags = struct.unpack('>h', rest[9:11])[0]
|
|---|
| 419 | self.dlen = struct.unpack('>l', rest[11:15])[0]
|
|---|
| 420 | self.rlen = struct.unpack('>l', rest[15:19])[0]
|
|---|
| 421 |
|
|---|
| 422 | self.FName = fname
|
|---|
| 423 | self.FInfo = FInfo()
|
|---|
| 424 | self.FInfo.Creator = creator
|
|---|
| 425 | self.FInfo.Type = type
|
|---|
| 426 | self.FInfo.Flags = flags
|
|---|
| 427 |
|
|---|
| 428 | self.state = _DID_HEADER
|
|---|
| 429 |
|
|---|
| 430 | def read(self, *n):
|
|---|
| 431 | if self.state != _DID_HEADER:
|
|---|
| 432 | raise Error, 'Read data at wrong time'
|
|---|
| 433 | if n:
|
|---|
| 434 | n = n[0]
|
|---|
| 435 | n = min(n, self.dlen)
|
|---|
| 436 | else:
|
|---|
| 437 | n = self.dlen
|
|---|
| 438 | rv = ''
|
|---|
| 439 | while len(rv) < n:
|
|---|
| 440 | rv = rv + self._read(n-len(rv))
|
|---|
| 441 | self.dlen = self.dlen - n
|
|---|
| 442 | return rv
|
|---|
| 443 |
|
|---|
| 444 | def close_data(self):
|
|---|
| 445 | if self.state != _DID_HEADER:
|
|---|
| 446 | raise Error, 'close_data at wrong time'
|
|---|
| 447 | if self.dlen:
|
|---|
| 448 | dummy = self._read(self.dlen)
|
|---|
| 449 | self._checkcrc()
|
|---|
| 450 | self.state = _DID_DATA
|
|---|
| 451 |
|
|---|
| 452 | def read_rsrc(self, *n):
|
|---|
| 453 | if self.state == _DID_HEADER:
|
|---|
| 454 | self.close_data()
|
|---|
| 455 | if self.state != _DID_DATA:
|
|---|
| 456 | raise Error, 'Read resource data at wrong time'
|
|---|
| 457 | if n:
|
|---|
| 458 | n = n[0]
|
|---|
| 459 | n = min(n, self.rlen)
|
|---|
| 460 | else:
|
|---|
| 461 | n = self.rlen
|
|---|
| 462 | self.rlen = self.rlen - n
|
|---|
| 463 | return self._read(n)
|
|---|
| 464 |
|
|---|
| 465 | def close(self):
|
|---|
| 466 | if self.rlen:
|
|---|
| 467 | dummy = self.read_rsrc(self.rlen)
|
|---|
| 468 | self._checkcrc()
|
|---|
| 469 | self.state = _DID_RSRC
|
|---|
| 470 | self.ifp.close()
|
|---|
| 471 |
|
|---|
| 472 | def hexbin(inp, out):
|
|---|
| 473 | """(infilename, outfilename) - Decode binhexed file"""
|
|---|
| 474 | ifp = HexBin(inp)
|
|---|
| 475 | finfo = ifp.FInfo
|
|---|
| 476 | if not out:
|
|---|
| 477 | out = ifp.FName
|
|---|
| 478 |
|
|---|
| 479 | ofp = open(out, 'wb')
|
|---|
| 480 | # XXXX Do translation on non-mac systems
|
|---|
| 481 | while 1:
|
|---|
| 482 | d = ifp.read(128000)
|
|---|
| 483 | if not d: break
|
|---|
| 484 | ofp.write(d)
|
|---|
| 485 | ofp.close()
|
|---|
| 486 | ifp.close_data()
|
|---|
| 487 |
|
|---|
| 488 | d = ifp.read_rsrc(128000)
|
|---|
| 489 | if d:
|
|---|
| 490 | ofp = openrsrc(out, 'wb')
|
|---|
| 491 | ofp.write(d)
|
|---|
| 492 | while 1:
|
|---|
| 493 | d = ifp.read_rsrc(128000)
|
|---|
| 494 | if not d: break
|
|---|
| 495 | ofp.write(d)
|
|---|
| 496 | ofp.close()
|
|---|
| 497 |
|
|---|
| 498 | ifp.close()
|
|---|
| 499 |
|
|---|
| 500 | def _test():
|
|---|
| 501 | fname = sys.argv[1]
|
|---|
| 502 | binhex(fname, fname+'.hqx')
|
|---|
| 503 | hexbin(fname+'.hqx', fname+'.viahqx')
|
|---|
| 504 | #hexbin(fname, fname+'.unpacked')
|
|---|
| 505 | sys.exit(1)
|
|---|
| 506 |
|
|---|
| 507 | if __name__ == '__main__':
|
|---|
| 508 | _test()
|
|---|
