home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_936 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  9.2 KB  |  293 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __license__ = 'GPL v3'
  5. __copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'
  6. import struct
  7. from calibre.ebooks.lrf import LRFParseError
  8.  
  9. class Tag(object):
  10.     tags = {
  11.         0: (6, '*ObjectStart'),
  12.         1: (0, '*ObjectEnd'),
  13.         2: (4, '*ObjectInfoLink'),
  14.         3: (4, '*Link'),
  15.         4: (4, '*StreamSize'),
  16.         5: (0, '*StreamStart'),
  17.         6: (0, '*StreamEnd'),
  18.         7: (4, None),
  19.         8: (4, None),
  20.         9: (4, None),
  21.         10: (4, None),
  22.         11: ('type_one', '*ContainedObjectsList'),
  23.         13: (2, None),
  24.         14: (2, None),
  25.         17: (2, None),
  26.         18: (2, None),
  27.         19: (2, None),
  28.         20: (2, None),
  29.         21: (2, None),
  30.         22: ('string', None),
  31.         23: (4, None),
  32.         24: (4, None),
  33.         25: (2, None),
  34.         26: (2, None),
  35.         27: (2, None),
  36.         28: (2, None),
  37.         29: (2, None),
  38.         30: (2, None),
  39.         33: (2, None),
  40.         34: (2, None),
  41.         35: (2, None),
  42.         36: (2, None),
  43.         37: (2, None),
  44.         38: (2, None),
  45.         39: (2, None),
  46.         40: (2, None),
  47.         41: (6, None),
  48.         42: (2, None),
  49.         43: (2, None),
  50.         44: (2, None),
  51.         45: (4, None),
  52.         46: (2, None),
  53.         49: (2, None),
  54.         50: (2, None),
  55.         51: (2, None),
  56.         52: (4, None),
  57.         53: (2, None),
  58.         54: (2, None),
  59.         55: (4, None),
  60.         56: (2, None),
  61.         57: (2, None),
  62.         58: (2, None),
  63.         60: (2, None),
  64.         61: (2, None),
  65.         62: (2, None),
  66.         65: (2, None),
  67.         66: (2, None),
  68.         68: (4, None),
  69.         69: (4, None),
  70.         70: (2, None),
  71.         71: (2, None),
  72.         72: (2, None),
  73.         73: (8, None),
  74.         74: (8, None),
  75.         75: (4, None),
  76.         76: (4, None),
  77.         77: (0, None),
  78.         78: (12, None),
  79.         81: (2, None),
  80.         82: (2, None),
  81.         83: (4, None),
  82.         84: (2, '*StreamFlags'),
  83.         85: ('string', None),
  84.         86: (2, None),
  85.         87: (2, None),
  86.         88: (2, None),
  87.         89: ('string', None),
  88.         90: ('string', None),
  89.         91: (4, None),
  90.         92: ('type_one', None),
  91.         93: ('string', None),
  92.         94: (2, None),
  93.         97: (2, None),
  94.         98: (0, None),
  95.         99: (0, None),
  96.         100: (0, None),
  97.         101: (0, None),
  98.         102: (0, None),
  99.         103: (0, None),
  100.         104: (0, None),
  101.         105: (0, None),
  102.         106: (0, None),
  103.         107: (0, None),
  104.         108: (8, None),
  105.         109: (2, None),
  106.         110: (0, None),
  107.         113: (0, None),
  108.         114: (0, None),
  109.         115: (10, None),
  110.         117: (2, None),
  111.         118: (2, None),
  112.         119: (2, None),
  113.         120: ('tag_78', None),
  114.         121: (2, None),
  115.         122: (2, None),
  116.         123: (4, None),
  117.         124: (4, '*ParentPageTree'),
  118.         129: (0, None),
  119.         130: (0, None),
  120.         161: (4, None),
  121.         162: (0, None),
  122.         165: ('unknown', None),
  123.         166: (0, None),
  124.         167: (4, None),
  125.         168: (0, None),
  126.         169: (0, None),
  127.         170: (0, None),
  128.         171: (0, None),
  129.         172: (0, None),
  130.         173: (0, None),
  131.         174: (0, None),
  132.         177: (0, None),
  133.         178: (0, None),
  134.         179: (0, None),
  135.         180: (0, None),
  136.         181: (0, None),
  137.         182: (0, None),
  138.         183: (0, None),
  139.         184: (0, None),
  140.         185: (0, None),
  141.         186: (0, None),
  142.         187: (0, None),
  143.         188: (0, None),
  144.         189: (0, None),
  145.         190: (0, None),
  146.         193: (0, None),
  147.         194: (0, None),
  148.         195: (2, None),
  149.         196: (0, None),
  150.         197: (2, None),
  151.         198: (2, None),
  152.         199: (0, None),
  153.         200: (2, None),
  154.         201: (0, None),
  155.         202: (2, None),
  156.         203: ('unknown', None),
  157.         204: (2, None),
  158.         209: (12, None),
  159.         210: (0, None),
  160.         212: (2, None),
  161.         214: (0, None),
  162.         215: (14, None),
  163.         216: (4, None),
  164.         217: (8, None),
  165.         218: (2, None),
  166.         219: (2, None),
  167.         220: (2, None),
  168.         221: (2, None),
  169.         241: (2, None),
  170.         242: (4, None),
  171.         243: (4, None),
  172.         244: (2, None),
  173.         245: (4, None),
  174.         246: (4, None),
  175.         247: (4, None),
  176.         248: (4, None),
  177.         249: (6, None) }
  178.     name_map = { }
  179.     for key in tags.keys():
  180.         temp = tags[key][1]
  181.         if temp is not None:
  182.             name_map[key] = temp
  183.             continue
  184.     
  185.     
  186.     def __init__(self, stream):
  187.         self.offset = stream.tell()
  188.         tag_id = struct.unpack('<BB', stream.read(2))
  189.         if tag_id[1] != 245:
  190.             raise LRFParseError('Bad tag ID %02X at %d' % (tag_id[1], self.offset))
  191.         tag_id[1] != 245
  192.         if tag_id[0] not in self.__class__.tags:
  193.             raise LRFParseError('Unknown tag ID: F5%02X' % tag_id[0])
  194.         tag_id[0] not in self.__class__.tags
  195.         self.id = 62720 + tag_id[0]
  196.         (size, self.name) = self.__class__.tags[tag_id[0]]
  197.         if isinstance(size, basestring):
  198.             parser = getattr(self, size + '_parser')
  199.             self.contents = parser(stream)
  200.         else:
  201.             self.contents = stream.read(size)
  202.  
  203.     
  204.     def __str__(self):
  205.         s = 'Tag %04X ' % self.id
  206.         if self.name:
  207.             s += self.name
  208.         
  209.         s += ' at %08X, contents: %s' % (self.offset, repr(self.contents))
  210.         return s
  211.  
  212.     
  213.     def byte(self):
  214.         
  215.         def fget(self):
  216.             if len(self.contents) != 1:
  217.                 raise LRFParseError('Bad parameter for tag ID: %04X' % self.id)
  218.             len(self.contents) != 1
  219.             return struct.unpack('<B', self.contents)[0]
  220.  
  221.         return property(fget = fget)
  222.  
  223.     byte = dynamic_property(byte)
  224.     
  225.     def word(self):
  226.         
  227.         def fget(self):
  228.             if len(self.contents) != 2:
  229.                 raise LRFParseError('Bad parameter for tag ID: %04X' % self.id)
  230.             len(self.contents) != 2
  231.             return struct.unpack('<H', self.contents)[0]
  232.  
  233.         return property(fget = fget)
  234.  
  235.     word = dynamic_property(word)
  236.     
  237.     def sword(self):
  238.         
  239.         def fget(self):
  240.             if len(self.contents) != 2:
  241.                 raise LRFParseError('Bad parameter for tag ID: %04X' % self.id)
  242.             len(self.contents) != 2
  243.             return struct.unpack('<h', self.contents)[0]
  244.  
  245.         return property(fget = fget)
  246.  
  247.     sword = dynamic_property(sword)
  248.     
  249.     def dword(self):
  250.         
  251.         def fget(self):
  252.             if len(self.contents) != 4:
  253.                 raise LRFParseError('Bad parameter for tag ID: %04X' % self.id)
  254.             len(self.contents) != 4
  255.             return struct.unpack('<I', self.contents)[0]
  256.  
  257.         return property(fget = fget)
  258.  
  259.     dword = dynamic_property(dword)
  260.     
  261.     def dummy_parser(self, stream):
  262.         raise LRFParseError('Unknown tag at %08X' % stream.tell())
  263.  
  264.     
  265.     def string_parser(self, stream):
  266.         size = struct.unpack('<H', stream.read(2))[0]
  267.         return unicode(stream.read(size), 'utf_16')
  268.  
  269.     string_parser = classmethod(string_parser)
  270.     
  271.     def type_one_parser(self, stream):
  272.         cnt = struct.unpack('<H', stream.read(2))[0]
  273.         res = []
  274.         while cnt > 0:
  275.             res.append(struct.unpack('<I', stream.read(4))[0])
  276.             cnt -= 1
  277.         return res
  278.  
  279.     
  280.     def tag_78_parser(self, stream):
  281.         pos = stream.tell()
  282.         res = []
  283.         res.append(struct.unpack('<I', stream.read(4))[0])
  284.         tag = Tag(stream)
  285.         if tag.id != 62742:
  286.             raise LRFParseError('Bad tag 78 at %08X' % pos)
  287.         tag.id != 62742
  288.         res.append(tag.contents)
  289.         res.append(struct.unpack('<H', stream.read(2))[0])
  290.         return res
  291.  
  292.  
  293.