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)
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)]