class ClassFile(object):
"""
Implements the JVM ClassFile (files typically ending in ``.class``).
To open an existing ClassFile::
from jawa import ClassFile
with open('HelloWorld.class') as fin:
cf = ClassFile(fin)
To save a newly created or modified ClassFile::
with open('HelloWorld.class', 'wb') as fout:
cf.save(fout)
To create a new ClassFile, use the helper :meth:`~ClassFile.create`::
from jawa import ClassFile
cf = ClassFile.create('HelloWorld')
with open('HelloWorld.class', 'wb') as fout:
cf.save(fout)
:meth:`~ClassFile.create` sets up some reasonable defaults equivelent to:
.. code-block:: java
public class HelloWorld extends java.lang.Object{
}
:param fio: any file-like object providing ``.read()``.
"""
#: The JVM ClassFile magic number.
MAGIC = 0xCAFEBABE
def __init__(self, fio=None):
# Default to J2SE_7
self._version = ClassVersion(0x32, 0)
self._constants = ConstantPool()
self._access_flags = Flags('>H', {
'acc_public': 0x0001,
'acc_final': 0x0010,
'acc_super': 0x0020,
'acc_interface': 0x0200,
'acc_abstract': 0x0400,
'acc_synthetic': 0x1000,
'acc_annotation': 0x2000,
'acc_enum': 0x4000
})
self._this = 0
self._super = 0
self._interfaces = []
self._fields = FieldTable(self)
self._methods = MethodTable(self)
self._attributes = AttributeTable(self)
if fio:
self._from_io(fio)
@classmethod
def create(cls, this, super_='java/lang/Object'):
"""
A utility method which sets up reasonable defaults for a new public
class.
:param this: The name of this class.
:param super_: The name of this class's superclass.
"""
cf = ClassFile()
cf.access_flags.acc_public = True
cf.access_flags.acc_super = True
cf._this = cf.constants.create_class(this).index
cf._super = cf.constants.create_class(super_).index
return cf
def save(self, fout):
"""
Saves the class to the file-like object `fout`.
"""
write = fout.write
write(pack('>IHH',
ClassFile.MAGIC,
self.version.minor,
self.version.major
))
self._constants._to_io(fout)
write(self.access_flags.pack())
write(pack('>HHH{0}H'.format(len(self._interfaces)),
self._this,
self._super,
len(self._interfaces),
*self._interfaces
))
self._fields._to_io(fout)
self._methods._to_io(fout)
self._attributes._to_io(fout)
# ------------
# Internal
# ------------
def _from_io(self, fio):
"""
Loads an existing JVM ClassFile from any file-like object.
"""
read = fio.read
if unpack('>I', fio.read(4))[0] != ClassFile.MAGIC:
raise ValueError('invalid magic number')
# The version is swapped on disk to (minor, major), so swap it back.
self.version = unpack('>HH', fio.read(4))[::-1]
self._constants._from_io(fio)
# ClassFile access_flags, see section #4.1 of the JVM specs.
self.access_flags.unpack(read(2))
# The CONSTANT_Class indexes for "this" class and its superclass.
# Interfaces are a simple list of CONSTANT_Class indexes.
self._this, self._super, interfaces_count = unpack('>HHH', read(6))
self._interfaces = unpack(
'>{0}H'.format(interfaces_count),
read(2 * interfaces_count)
)
self._fields._from_io(fio)
self._methods._from_io(fio)
self._attributes._from_io(fio)
# -------------
# Properties
# -------------
@property
def version(self):
"""
The :class:`~jawa.cf.ClassVersion` for this class.
Example::
>>> cf.version = 51, 0
>>> print(cf.version)
ClassVersion(major=51, minor=0)
>>> print(cf.version.major)
51
"""
return self._version
@version.setter
def version(self, (major, minor)):
self._version = ClassVersion(major, minor)
