| ## Copyright (C) 2004, 2005 Free Software Foundation |
| ## Written by Gary Benson <gbenson@redhat.com> |
| ## |
| ## This program is free software; you can redistribute it and/or modify |
| ## it under the terms of the GNU General Public License as published by |
| ## the Free Software Foundation; either version 2 of the License, or |
| ## (at your option) any later version. |
| ## |
| ## This program is distributed in the hope that it will be useful, |
| ## but WITHOUT ANY WARRANTY; without even the implied warranty of |
| ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| ## GNU General Public License for more details. |
| |
| """Read Java(TM) class files.""" |
| |
| import cStringIO as StringIO |
| import struct |
| |
| class Class: |
| def __init__(self, arg): |
| if hasattr(arg, "read"): |
| self.fp = arg |
| elif type(arg) == type(""): |
| if arg.startswith("\xca\xfe\xba\xbe"): |
| self.fp = StringIO.StringIO(arg) |
| else: |
| self.fp = open(arg, "r") |
| else: |
| raise TypeError, type(arg) |
| |
| magic = self._read_int() |
| assert magic == 0xcafebabeL |
| minor, major = self._read(">HH") |
| self.version = (major, minor) |
| |
| self.pool_integrity_checks = None |
| try: |
| assert False |
| except AssertionError: |
| self.pool_integrity_checks = [] |
| |
| self._read_constants_pool() |
| |
| self.access_flags = self._read_short() |
| self.name = self._read_reference_Class() |
| self.super = self._read_reference_Class() |
| |
| self.interfaces = self._read_interfaces() |
| self.fields = self._read_fieldsormethods() |
| self.methods = self._read_fieldsormethods() |
| self.attributes = self._read_attributes() |
| |
| if self.pool_integrity_checks is not None: |
| for index, tag in self.pool_integrity_checks: |
| assert self.constants[index][0] == tag |
| |
| del self.fp, self.pool_integrity_checks |
| |
| def __repr__(self): |
| result = [] |
| attrs = [attr for attr in dir(self) |
| if not attr.startswith("_") and attr != "Member"] |
| attrs.sort() |
| for attr in attrs: |
| result.append("%-13s %s" % ( |
| attr + ":", attr == "constants" and |
| "<ELIDED>" or repr(getattr(self, attr)))) |
| return "\n".join(result) |
| |
| def _read_constants_pool(self): |
| self.constants = {} |
| skip = False |
| for i in xrange(1, self._read_short()): |
| if skip: |
| skip = False |
| continue |
| tag = { |
| 1: "Utf8", 3: "Integer", 4: "Float", 5: "Long", |
| 6: "Double", 7: "Class", 8: "String", 9: "Fieldref", |
| 10: "Methodref", 11: "InterfaceMethodref", |
| 12: "NameAndType"}[self._read_byte()] |
| skip = tag in ("Long", "Double") # crack crack crack! |
| self.constants[i] = (tag, getattr(self, "_read_constant_" + tag)()) |
| |
| def _read_interfaces(self): |
| result = [] |
| for i in xrange(self._read_short()): |
| result.append(self._read_reference_Class()) |
| return result |
| |
| def _read_fieldsormethods(self): |
| result = [] |
| for i in xrange(self._read_short()): |
| result.append(self.Member(self)) |
| return result |
| |
| class Member: |
| def __init__(self, source): |
| self.access_flags = source._read_short() |
| self.name = source._read_reference_Utf8() |
| self.descriptor = source._read_reference_Utf8() |
| self.attributes = source._read_attributes() |
| |
| def __repr__(self): |
| result = [] |
| attrs = [attr for attr in dir(self) if not attr.startswith("_")] |
| attrs.sort() |
| for attr in attrs: |
| value = getattr(self, attr) |
| if attr == "attributes" and value.has_key("Code"): |
| value = value.copy() |
| value.update({"Code": "<ELIDED>"}) |
| result.append("%-13s %s" % ( |
| attr + ":", repr(value).replace( |
| "'Code': '<ELIDED>'", "'Code': <ELIDED>"))) |
| return ("\n%s" % (15 * " ")).join(result) |
| |
| def _read_attributes(self): |
| result = {} |
| for i in xrange(self._read_short()): |
| name = self._read_reference_Utf8() |
| data = self.fp.read(self._read_int()) |
| assert not result.has_key(name) |
| result[name] = data |
| return result |
| |
| # Constants pool reference reader convenience functions |
| |
| def _read_reference_Utf8(self): |
| return self._read_references("Utf8")[0] |
| |
| def _read_reference_Class(self): |
| return self._read_references("Class")[0] |
| |
| def _read_reference_Class_NameAndType(self): |
| return self._read_references("Class", "NameAndType") |
| |
| def _read_references(self, *args): |
| result = [] |
| for arg in args: |
| index = self._read_short() |
| if self.pool_integrity_checks is not None: |
| self.pool_integrity_checks.append((index, arg)) |
| result.append(index) |
| return result |
| |
| # Constants pool constant reader functions |
| |
| def _read_constant_Utf8(self): |
| constant = self.fp.read(self._read_short()) |
| try: |
| constant = constant.decode("utf-8") |
| except UnicodeError: |
| constant = _bork_utf8_decode(constant) |
| try: |
| constant = constant.encode("us-ascii") |
| except UnicodeError: |
| pass |
| return constant |
| |
| def _read_constant_Integer(self): |
| return self._read_int() |
| |
| def _read_constant_Float(self): |
| return self._read(">f")[0] |
| |
| def _read_constant_Long(self): |
| return self._read(">q")[0] |
| |
| def _read_constant_Double(self): |
| return self._read(">d")[0] |
| |
| _read_constant_Class = _read_reference_Utf8 |
| _read_constant_String = _read_reference_Utf8 |
| _read_constant_Fieldref = _read_reference_Class_NameAndType |
| _read_constant_Methodref = _read_reference_Class_NameAndType |
| _read_constant_InterfaceMethodref = _read_reference_Class_NameAndType |
| |
| def _read_constant_NameAndType(self): |
| return self._read_reference_Utf8(), self._read_reference_Utf8() |
| |
| # Generic reader functions |
| |
| def _read_int(self): |
| # XXX how else to read 32 bits on a 64-bit box? |
| h, l = map(long, self._read(">HH")) |
| return (h << 16) + l |
| |
| def _read_short(self): |
| return self._read(">H")[0] |
| |
| def _read_byte(self): |
| return self._read("B")[0] |
| |
| def _read(self, fmt): |
| return struct.unpack(fmt, self.fp.read(struct.calcsize(fmt))) |
| |
| def _bork_utf8_decode(data): |
| # more crack! |
| bytes, unicode = map(ord, data), "" |
| while bytes: |
| b1 = bytes.pop(0) |
| if b1 & 0x80: |
| assert b1 & 0x40 |
| b2 = bytes.pop(0) |
| assert b2 & 0xC0 == 0x80 |
| if b1 & 0x20: |
| assert not b1 & 0x10 |
| b3 = bytes.pop(0) |
| assert b3 & 0xC0 == 0x80 |
| unicode += unichr( |
| ((b1 & 0x0f) << 12) + ((b2 & 0x3f) << 6) + (b3 & 0x3f)) |
| else: |
| unicode += unichr(((b1 & 0x1f) << 6) + (b2 & 0x3f)) |
| else: |
| unicode += unichr(b1) |
| return unicode |
| |
| if __name__ == "__main__": |
| print Class("/usr/share/katana/build/ListDependentClasses.class") |
| |
