def new_integer(self, value):
# Allocate a new integer and set its class to be the integer class
result = Integer(self._nilObject, value)
result.set_class(self._integerClass)
# Return the freshly allocated integer
return result
def new_integer(self, value):
# Allocate a new integer and set its class to be the integer class
result = Integer(self._nilObject, value)
result.set_class(self._integerClass)
# Return the freshly allocated integer
return result
def new_integer(self, value):
# Allocate a new integer and set its class to be the integer class
result = Integer(self._nilObject)
result.set_class(self._integerClass)
# Set the embedded integer of the newly allocated integer
result.set_embedded_integer(value)
# Return the freshly allocated integer
return result
def read_location(self, obj):
# assert isinstance(obj, Object)
if self.is_set(obj):
return Integer(getattr(obj, "_primField" + str(field_idx)))
else:
return nilObject
def _transition_to_object_array(self, array, idx, value):
store = self._unerase(array._storage)
new_store = [None] * len(store)
for i, v in enumerate(store):
new_store[i] = Integer(v)
new_store[idx] = value
array._storage = _ObjectStrategy.new_storage_with_values(new_store)
array._strategy = _obj_strategy
def test_empty_to_int(self):
arr = Array.from_size(1)
self.assertIsInstance(arr._strategy, _EmptyStrategy)
int_obj = Integer(42)
arr.set_indexable_field(0, int_obj)
self.assertIsInstance(arr._strategy, _LongStrategy)
self.assertEqual(42, arr.get_indexable_field(0).get_embedded_integer())
def _div(ivkbl, frame, interpreter):
right_obj = frame.pop()
left = frame.pop()
# Do operation and perform conversion to Integer if required
result = left.get_embedded_biginteger() / right_obj.get_embedded_value()
if Integer.value_fits(result):
frame.push(self._universe.new_integer(result))
else:
frame.push(self._universe.new_biginteger(result))
def test_copy_and_extend_partially_empty(self):
arr = Array.from_size(3)
int_obj = Integer(42)
arr.set_indexable_field(0, int_obj)
self.assertIsInstance(arr._strategy, _PartiallyEmptyStrategy)
new_arr = arr.copy_and_extend_with(int_obj)
self.assertIsNot(arr, new_arr)
self.assertEqual(4, new_arr.get_number_of_indexable_fields())
self.assertIsInstance(new_arr._strategy, _PartiallyEmptyStrategy)
def _div(ivkbl, frame, interpreter):
right_obj = frame.pop()
left = frame.pop()
# Do operation and perform conversion to Integer if required
result = left.get_embedded_biginteger(
) / right_obj.get_embedded_value()
if Integer.value_fits(result):
frame.push(self._universe.new_integer(result))
else:
frame.push(self._universe.new_biginteger(result))
def _literal_number(self, mgenc):
if self._sym == Symbol.Minus:
val = self._negative_decimal()
else:
val = self._literal_decimal()
if Integer.value_fits(val):
lit = self._universe.new_integer(val)
else:
lit = self._universe.new_biginteger(val)
mgenc.add_literal_if_absent(lit)
self._bc_gen.emitPUSHCONSTANT(mgenc, lit)
def _literal_number(self, mgenc):
if self._sym == Symbol.Minus:
val = self._negative_decimal()
else:
val = self._literal_decimal()
if Integer.value_fits(val):
lit = self._universe.new_integer(val)
else:
lit = self._universe.new_biginteger(val)
mgenc.add_literal_if_absent(lit)
self._bc_gen.emitPUSHCONSTANT(mgenc, lit)
class BigIntegerTestCase(unittest.TestCase):
def setUp(self):
self.big_integer = BigInteger(Object(None), 30000000000)
self.integer = Integer(Object(None), 3)
def test_get_embedded_biginteger(self):
self.assertEqual(30000000000, self.big_integer.get_embedded_biginteger())
def test_get_embedded_value(self):
self.assertEqual(30000000000, self.big_integer.get_embedded_value())
def test_get_embedded_value_integer_and_big_integer(self):
self.assertEqual(3, self.integer.get_embedded_value())
self.assertEqual(30000000000, self.big_integer.get_embedded_value())
def do_layout_mate_semantics(self, frame, obj, value):
assert obj is not None
environment = frame.get_meta_object_environment(
) or obj.get_meta_object_environment()
# No esta definido o es Nil
if environment is None or not isinstance(environment, Object):
return None
method = self._lookup_node.lookup_meta_invokable(environment)
if method is None:
# El mate enviroment no define el methodo correspondiente a este nodo
return None
return method.invoke(obj,
[Integer(self._som_node.field_idx() + 1), value],
True)
def _set_remaining_with_block_as_long(array, block, size, next_i, storage):
block_method = block.get_method()
while next_i < size:
put_all_long_driver.jit_merge_point(block_method = block_method)
result = block_method.invoke(block, [])
if isinstance(result, Integer):
storage[next_i] = result.get_embedded_integer()
else:
# something else, so, let's go to the object strategy
new_storage = [None] * size
for i in range(0, next_i + 1):
new_storage[i] = Integer(storage[i])
_ArrayStrategy._set_remaining_with_block_as_obj(array, block,
size,
next_i + 1,
new_storage)
return
next_i += 1
array._strategy = _long_strategy
array._storage = _long_strategy._erase(storage)
def _erase(self, anInt):
assert isinstance(anInt, int)
return self.__erase(Integer(anInt))
def _push_long_result(self, frame, result):
# Check with integer bounds and push:
if Integer.value_fits(result):
frame.push(self._universe.new_integer(int(result)))
else:
frame.push(self._universe.new_biginteger(result))
def read_location(self, obj):
if self.is_set(obj):
return Integer(obj._primFields[self._ext_idx])
else:
return nilObject
def setUp(self):
self.big_integer = BigInteger(Object(None), 30000000000)
self.integer = Integer(Object(None), 3)
def get_idx(self, storage, idx):
store = self._unerase(storage)
assert isinstance(store, list)
assert isinstance(store[idx], int)
return Integer(store[idx])
def as_arguments_array(self, storage):
store = self._unerase(storage)
return [Integer(v) for v in store]
def get_meta_args(self, frame):
return [Integer(self._som_node.field_idx() + 1)]
def get_meta_args(self, frame):
value = self._som_node.get_expr().execute(frame)
return [Integer(self._som_node.frame_idx() + 1), Context(frame), value]
def new_integer(value):
assert isinstance(value, int)
return Integer(value)
def get_meta_args(self, frame):
return [Integer(self._som_node.frame_idx() + 1), Context(frame)]
