WARNING! Access to this system is limited to authorised users only.
Unauthorised users may be subject to prosecution.
Unauthorised access to this system is a criminal offence under Australian law (Federal Crimes Act 1914 Part VIA)
It is a criminal offence to:
(1) Obtain access to data without authority. -Penalty 2 years imprisonment.
(2) Damage, delete, alter or insert data without authority. -Penalty 10 years imprisonment.
User activity is monitored and recorded. Anyone using this system expressly consents to such monitoring and recording.

To protect your data, the CISO officer has suggested users to enable 2FA as soon as possible.
Currently 2.7% of users enabled 2FA.

Commit 8e738a19 authored by Stefan Marr's avatar Stefan Marr
Browse files

Added MethodGenerationContext class


Signed-off-by: default avatarStefan Marr <git@stefan-marr.de>
parent 70635d54
from som.interpreter.bytecodes import Bytecodes as BC
class MethodGenerationContext(object):
def __init__(self):
self._holder_genc = None
self._outer_genc = None
self._block_method = None
self._signature = None
self._arguments = []
self._primitive = None
self._locals = []
self._literals = []
self._finished = False
self._bytecode = []
def set_holder(self, cgenc):
self._holder_genc = cgenc
def add_argument(self, arg):
self._arguments.append(arg)
def is_primitive(self):
return self._primitive
def assemblePrimitive(self, universe):
return Primitive.get_empty_primitive(self._signature.get_string(), universe)
def assemble(self, universe):
# create a method instance with the given number of bytecodes and literals
num_literals = len(self._literals)
meth = universe.new_method(self._signature, len(self._bytecode), num_literals)
# populate the fields that are immediately available
num_locals = len(locals)
meth.set_number_of_locals(universe.new_integer(num_locals))
meth.set_maximum_number_of_stack_elements(universe.new_integer(self._compute_stack_depth()))
# copy literals into the method
i = 0
for l in self._literals:
meth.set_indexableField(i, l)
i += 1
# copy bytecodes into method
i = 0
for bc in self._bytecode:
meth.set_bytecode(i, bc)
i += 1
# return the method - the holder field is to be set later on!
return meth
def _compute_stack_depth(self):
depth = 0
max_depth = 0
i = 0
for bc in self._bytecode:
if BC.stack_effect_depends_on_send(bc):
signature = self._literals[self._bytecode[i + 1]]
depth += BC.get_stack_effect(bc, signature.get_number_of_signature_arguments())
else:
depth += BC.get_stack_effect(bc)
i += BC.get_bytecode_length(bc)
if depth > max_depth:
max_depth = depth
return max_depth
def set_primitive(self, boolean):
self._primitive = boolean
def set_signature(self, sig):
self._signature = sig
def add_argument_if_absent(self, arg):
if arg in self._locals:
return False
self._arguments.append(arg)
return True
def is_finished(self):
return self._finished
def set_finished(self, boolean = True):
self._finished = boolean
def add_local_if_absent(self, local):
if local in self._locals:
return False
self._locals.append(local)
return True
def add_local(self, local):
self._locals.append(local)
def remove_last_bytecode(self):
self._bytecode = self._bytecode[:-1]
def is_block_method(self):
return self._block_method
def add_literal_if_absent(self, lit):
if lit in self._literals:
return False
self._literals.append(lit)
return True
def set_is_block_method(self, boolean):
self._block_method = boolean
def get_holder(self):
return self._holder_genc
def set_outer(self, mgenc):
self._outer_genc = mgenc
def add_literal(self, lit):
self._literals.append(lit)
def find_var(self, var, triplet):
# triplet: index, context, isArgument
triplet[0] = self._locals.index(var)
if triplet[0] == -1:
triplet[0] = self._arguments.index(var)
if triplet[0] == -1:
if not self._outer_genc:
return False
else:
triplet[1] = triplet[1] + 1
return self._outer_genc.find_var(var, triplet)
else:
triplet[2] = True
return True
def has_field(self, field):
return self._holder_genc.has_field(field)
def get_field_index(self, field):
return self._holder_genc.get_field_index(field)
def get_number_of_arguments(self):
return len(self._arguments)
def add_bytecode(self, bc):
self._bytecode.append(bc)
def find_literal_index(self, lit):
return self._literals.index(lit)
def get_outer(self):
return self._outer_genc
def get_signature(self):
return self._signature
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment