home *** CD-ROM | disk | FTP | other *** search
/ com!online 2005 April / com_0405_1.iso / opensource / BTpp-0.5.4-bin.exe / $INSTDIR / BT++.exe / gzip.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-04-19  |  11.9 KB  |  420 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.2)
  3.  
  4. import struct
  5. import sys
  6. import time
  7. import zlib
  8. import __builtin__
  9. __all__ = [
  10.     'GzipFile',
  11.     'open']
  12. (FTEXT, FHCRC, FEXTRA, FNAME, FCOMMENT) = (1, 2, 4, 8, 16)
  13. (READ, WRITE) = (1, 2)
  14.  
  15. def write32(output, value):
  16.     output.write(struct.pack('<l', value))
  17.  
  18.  
  19. def write32u(output, value):
  20.     if value < 0:
  21.         value = value + 0x100000000L
  22.     
  23.     output.write(struct.pack('<L', value))
  24.  
  25.  
  26. def read32(input):
  27.     return struct.unpack('<l', input.read(4))[0]
  28.  
  29.  
  30. def open(filename, mode = 'rb', compresslevel = 9):
  31.     return GzipFile(filename, mode, compresslevel)
  32.  
  33.  
  34. class GzipFile:
  35.     myfileobj = None
  36.     
  37.     def __init__(self, filename = None, mode = None, compresslevel = 9, fileobj = None):
  38.         if mode and 'b' not in mode:
  39.             mode += 'b'
  40.         
  41.         if fileobj is None:
  42.             if not mode:
  43.                 pass
  44.             fileobj = self.myfileobj = __builtin__.open(filename, 'rb')
  45.         
  46.         if filename is None:
  47.             if hasattr(fileobj, 'name'):
  48.                 filename = fileobj.name
  49.             else:
  50.                 filename = ''
  51.         
  52.         if mode is None:
  53.             if hasattr(fileobj, 'mode'):
  54.                 mode = fileobj.mode
  55.             else:
  56.                 mode = 'rb'
  57.         
  58.         if mode[0:1] == 'r':
  59.             self.mode = READ
  60.             self._new_member = 1
  61.             self.extrabuf = ''
  62.             self.extrasize = 0
  63.             self.filename = filename
  64.         elif mode[0:1] == 'w' or mode[0:1] == 'a':
  65.             self.mode = WRITE
  66.             self._init_write(filename)
  67.             self.compress = zlib.compressobj(compresslevel, zlib.DEFLATED, -(zlib.MAX_WBITS), zlib.DEF_MEM_LEVEL, 0)
  68.         else:
  69.             raise ValueError, 'Mode ' + mode + ' not supported'
  70.         self.fileobj = fileobj
  71.         self.offset = 0
  72.         if self.mode == WRITE:
  73.             self._write_gzip_header()
  74.         
  75.  
  76.     
  77.     def __repr__(self):
  78.         s = repr(self.fileobj)
  79.         return '<gzip ' + s[1:-1] + ' ' + hex(id(self)) + '>'
  80.  
  81.     
  82.     def _init_write(self, filename):
  83.         if filename[-3:] != '.gz':
  84.             filename = filename + '.gz'
  85.         
  86.         self.filename = filename
  87.         self.crc = zlib.crc32('')
  88.         self.size = 0
  89.         self.writebuf = []
  90.         self.bufsize = 0
  91.  
  92.     
  93.     def _write_gzip_header(self):
  94.         self.fileobj.write('\x1f\x8b')
  95.         self.fileobj.write('\x08')
  96.         fname = self.filename[:-3]
  97.         flags = 0
  98.         if fname:
  99.             flags = FNAME
  100.         
  101.         self.fileobj.write(chr(flags))
  102.         write32u(self.fileobj, long(time.time()))
  103.         self.fileobj.write('\x02')
  104.         self.fileobj.write('\xff')
  105.         if fname:
  106.             self.fileobj.write(fname + '\x00')
  107.         
  108.  
  109.     
  110.     def _init_read(self):
  111.         self.crc = zlib.crc32('')
  112.         self.size = 0
  113.  
  114.     
  115.     def _read_gzip_header(self):
  116.         magic = self.fileobj.read(2)
  117.         if magic != '\x1f\x8b':
  118.             raise IOError, 'Not a gzipped file'
  119.         
  120.         method = ord(self.fileobj.read(1))
  121.         if method != 8:
  122.             raise IOError, 'Unknown compression method'
  123.         
  124.         flag = ord(self.fileobj.read(1))
  125.         self.fileobj.read(6)
  126.         if flag & FEXTRA:
  127.             xlen = ord(self.fileobj.read(1))
  128.             xlen = xlen + 256 * ord(self.fileobj.read(1))
  129.             self.fileobj.read(xlen)
  130.         
  131.         if flag & FNAME:
  132.             while 1:
  133.                 s = self.fileobj.read(1)
  134.                 if not s or s == '\x00':
  135.                     break
  136.                 
  137.         
  138.         if flag & FCOMMENT:
  139.             while 1:
  140.                 s = self.fileobj.read(1)
  141.                 if not s or s == '\x00':
  142.                     break
  143.                 
  144.         
  145.         if flag & FHCRC:
  146.             self.fileobj.read(2)
  147.         
  148.  
  149.     
  150.     def write(self, data):
  151.         if self.fileobj is None:
  152.             raise ValueError, 'write() on closed GzipFile object'
  153.         
  154.         if len(data) > 0:
  155.             self.size = self.size + len(data)
  156.             self.crc = zlib.crc32(data, self.crc)
  157.             self.fileobj.write(self.compress.compress(data))
  158.             self.offset += len(data)
  159.         
  160.  
  161.     
  162.     def read(self, size = -1):
  163.         if self.extrasize <= 0 and self.fileobj is None:
  164.             return ''
  165.         
  166.         readsize = 1024
  167.         if size < 0:
  168.             
  169.             try:
  170.                 while 1:
  171.                     self._read(readsize)
  172.                     readsize = readsize * 2
  173.             except EOFError:
  174.                 size = self.extrasize
  175.  
  176.         else:
  177.             
  178.             try:
  179.                 while size > self.extrasize:
  180.                     self._read(readsize)
  181.                     readsize = readsize * 2
  182.             except EOFError:
  183.                 if size > self.extrasize:
  184.                     size = self.extrasize
  185.                 
  186.             except:
  187.                 size > self.extrasize
  188.  
  189.         chunk = self.extrabuf[:size]
  190.         self.extrabuf = self.extrabuf[size:]
  191.         self.extrasize = self.extrasize - size
  192.         self.offset += size
  193.         return chunk
  194.  
  195.     
  196.     def _unread(self, buf):
  197.         self.extrabuf = buf + self.extrabuf
  198.         self.extrasize = len(buf) + self.extrasize
  199.         self.offset -= len(buf)
  200.  
  201.     
  202.     def _read(self, size = 1024):
  203.         if self.fileobj is None:
  204.             raise EOFError, 'Reached EOF'
  205.         
  206.         if self._new_member:
  207.             pos = self.fileobj.tell()
  208.             self.fileobj.seek(0, 2)
  209.             if pos == self.fileobj.tell():
  210.                 raise EOFError, 'Reached EOF'
  211.             else:
  212.                 self.fileobj.seek(pos)
  213.             self._init_read()
  214.             self._read_gzip_header()
  215.             self.decompress = zlib.decompressobj(-(zlib.MAX_WBITS))
  216.             self._new_member = 0
  217.         
  218.         buf = self.fileobj.read(size)
  219.         if buf == '':
  220.             uncompress = self.decompress.flush()
  221.             self._read_eof()
  222.             self._add_read_data(uncompress)
  223.             raise EOFError, 'Reached EOF'
  224.         
  225.         uncompress = self.decompress.decompress(buf)
  226.         self._add_read_data(uncompress)
  227.         if self.decompress.unused_data != '':
  228.             self.fileobj.seek(-len(self.decompress.unused_data) + 8, 1)
  229.             self._read_eof()
  230.             self._new_member = 1
  231.         
  232.  
  233.     
  234.     def _add_read_data(self, data):
  235.         self.crc = zlib.crc32(data, self.crc)
  236.         self.extrabuf = self.extrabuf + data
  237.         self.extrasize = self.extrasize + len(data)
  238.         self.size = self.size + len(data)
  239.  
  240.     
  241.     def _read_eof(self):
  242.         self.fileobj.seek(-8, 1)
  243.         crc32 = read32(self.fileobj)
  244.         isize = read32(self.fileobj)
  245.         if crc32 % 0x100000000L != self.crc % 0x100000000L:
  246.             raise ValueError, 'CRC check failed'
  247.         elif isize != self.size:
  248.             raise ValueError, 'Incorrect length of data produced'
  249.         
  250.  
  251.     
  252.     def close(self):
  253.         if self.mode == WRITE:
  254.             self.fileobj.write(self.compress.flush())
  255.             write32(self.fileobj, self.crc)
  256.             write32(self.fileobj, self.size)
  257.             self.fileobj = None
  258.         elif self.mode == READ:
  259.             self.fileobj = None
  260.         
  261.         if self.myfileobj:
  262.             self.myfileobj.close()
  263.             self.myfileobj = None
  264.         
  265.  
  266.     
  267.     def __del__(self):
  268.         
  269.         try:
  270.             if self.myfileobj is None and self.fileobj is None:
  271.                 return None
  272.         except AttributeError:
  273.             return None
  274.  
  275.         self.close()
  276.  
  277.     
  278.     def flush(self):
  279.         self.fileobj.flush()
  280.  
  281.     
  282.     def isatty(self):
  283.         return 0
  284.  
  285.     
  286.     def tell(self):
  287.         return self.offset
  288.  
  289.     
  290.     def rewind(self):
  291.         if self.mode != READ:
  292.             raise IOError("Can't rewind in write mode")
  293.         
  294.         self.fileobj.seek(0)
  295.         self._new_member = 1
  296.         self.extrabuf = ''
  297.         self.extrasize = 0
  298.         self.offset = 0
  299.  
  300.     
  301.     def seek(self, offset):
  302.         if self.mode == WRITE:
  303.             if offset < self.offset:
  304.                 raise IOError('Negative seek in write mode')
  305.             
  306.             count = offset - self.offset
  307.             for i in range(count / 1024):
  308.                 self.write(1024 * '\x00')
  309.             
  310.             self.write((count % 1024) * '\x00')
  311.         elif self.mode == READ:
  312.             if offset < self.offset:
  313.                 self.rewind()
  314.             
  315.             count = offset - self.offset
  316.             for i in range(count / 1024):
  317.                 self.read(1024)
  318.             
  319.             self.read(count % 1024)
  320.         
  321.  
  322.     
  323.     def readline(self, size = -1):
  324.         if size < 0:
  325.             size = sys.maxint
  326.         
  327.         bufs = []
  328.         readsize = min(100, size)
  329.         while 1:
  330.             if size == 0:
  331.                 return ''.join(bufs)
  332.             
  333.             c = self.read(readsize)
  334.             i = c.find('\n')
  335.             if size is not None:
  336.                 if i == -1 and len(c) > size:
  337.                     i = size - 1
  338.                 elif size <= i:
  339.                     i = size - 1
  340.                 
  341.             
  342.             if i >= 0 or c == '':
  343.                 bufs.append(c[:i + 1])
  344.                 self._unread(c[i + 1:])
  345.                 return ''.join(bufs)
  346.             
  347.             bufs.append(c)
  348.             size = size - len(c)
  349.             readsize = min(size, readsize * 2)
  350.  
  351.     
  352.     def readlines(self, sizehint = 0):
  353.         if sizehint <= 0:
  354.             sizehint = sys.maxint
  355.         
  356.         L = []
  357.         while sizehint > 0:
  358.             line = self.readline()
  359.             if line == '':
  360.                 break
  361.             
  362.             L.append(line)
  363.             sizehint = sizehint - len(line)
  364.         return L
  365.  
  366.     
  367.     def writelines(self, L):
  368.         for line in L:
  369.             self.write(line)
  370.         
  371.  
  372.  
  373.  
  374. def _test():
  375.     args = sys.argv[1:]
  376.     if args:
  377.         pass
  378.     decompress = args[0] == '-d'
  379.     if decompress:
  380.         args = args[1:]
  381.     
  382.     if not args:
  383.         args = [
  384.             '-']
  385.     
  386.     for arg in args:
  387.         if decompress:
  388.             if arg == '-':
  389.                 f = GzipFile(filename = '', mode = 'rb', fileobj = sys.stdin)
  390.                 g = sys.stdout
  391.             elif arg[-3:] != '.gz':
  392.                 print "filename doesn't end in .gz:", `arg`
  393.                 continue
  394.             
  395.             f = open(arg, 'rb')
  396.             g = __builtin__.open(arg[:-3], 'wb')
  397.         elif arg == '-':
  398.             f = sys.stdin
  399.             g = GzipFile(filename = '', mode = 'wb', fileobj = sys.stdout)
  400.         else:
  401.             f = __builtin__.open(arg, 'rb')
  402.             g = open(arg + '.gz', 'wb')
  403.         while 1:
  404.             chunk = f.read(1024)
  405.             if not chunk:
  406.                 break
  407.             
  408.             g.write(chunk)
  409.         if g is not sys.stdout:
  410.             g.close()
  411.         
  412.         if f is not sys.stdin:
  413.             f.close()
  414.         
  415.     
  416.  
  417. if __name__ == '__main__':
  418.     _test()
  419.  
  420.