Retro68/gcc/libjava/contrib/classfile.py

222 lines
7.2 KiB
Python
Raw Normal View History

2012-03-27 23:13:14 +00:00
## 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")