def _post_type_conversion(self, expression): expr = get(expression.expression) val = TemporaryVariable(self._node) operation = TypeConversion(val, expr, expression.type) operation.set_expression(expression) self._result.append(operation) set_val(expression, val)
def _post_binary_operation(self, expression): left = get(expression.expression_left) right = get(expression.expression_right) val = TemporaryVariable(self._node) if expression.type in _signed_to_unsigned: new_left = TemporaryVariable(self._node) conv_left = TypeConversion(new_left, left, ElementaryType('int256')) conv_left.set_expression(expression) self._result.append(conv_left) if expression.type != BinaryOperationType.RIGHT_SHIFT_ARITHMETIC: new_right = TemporaryVariable(self._node) conv_right = TypeConversion(new_right, right, ElementaryType('int256')) conv_right.set_expression(expression) self._result.append(conv_right) else: new_right = right new_final = TemporaryVariable(self._node) operation = Binary(new_final, new_left, new_right, _signed_to_unsigned[expression.type]) operation.set_expression(expression) self._result.append(operation) conv_final = TypeConversion(val, new_final, ElementaryType('uint256')) conv_final.set_expression(expression) self._result.append(conv_final) else: operation = Binary(val, left, right, _binary_to_binary[expression.type]) operation.set_expression(expression) self._result.append(operation) set_val(expression, val)
def _post_call_expression(self, expression): # pylint: disable=too-many-branches,too-many-statements,too-many-locals assert isinstance(expression, CallExpression) expression_called = expression.called called = get(expression_called) args = [get(a) for a in expression.arguments if a] for arg in args: arg_ = Argument(arg) arg_.set_expression(expression) self._result.append(arg_) if isinstance(called, Function): # internal call # If tuple if expression.type_call.startswith( "tuple(") and expression.type_call != "tuple()": val = TupleVariable(self._node) else: val = TemporaryVariable(self._node) internal_call = InternalCall(called, len(args), val, expression.type_call) internal_call.set_expression(expression) self._result.append(internal_call) set_val(expression, val) # User defined types elif (isinstance(called, TypeAlias) and isinstance(expression_called, MemberAccess) and expression_called.member_name in ["wrap", "unwrap"] and len(args) == 1): val = TemporaryVariable(self._node) var = TypeConversion(val, args[0], called) var.set_expression(expression) val.set_type(called) self._result.append(var) set_val(expression, val) # yul things elif called.name == "caller()": val = TemporaryVariable(self._node) var = Assignment(val, SolidityVariableComposed("msg.sender"), "uint256") self._result.append(var) set_val(expression, val) elif called.name == "origin()": val = TemporaryVariable(self._node) var = Assignment(val, SolidityVariableComposed("tx.origin"), "uint256") self._result.append(var) set_val(expression, val) elif called.name == "extcodesize(uint256)": val = ReferenceVariable(self._node) var = Member(args[0], Constant("codesize"), val) self._result.append(var) set_val(expression, val) elif called.name == "selfbalance()": val = TemporaryVariable(self._node) var = TypeConversion(val, SolidityVariable("this"), ElementaryType("address")) val.set_type(ElementaryType("address")) self._result.append(var) val1 = ReferenceVariable(self._node) var1 = Member(val, Constant("balance"), val1) self._result.append(var1) set_val(expression, val1) elif called.name == "address()": val = TemporaryVariable(self._node) var = TypeConversion(val, SolidityVariable("this"), ElementaryType("address")) val.set_type(ElementaryType("address")) self._result.append(var) set_val(expression, val) elif called.name == "callvalue()": val = TemporaryVariable(self._node) var = Assignment(val, SolidityVariableComposed("msg.value"), "uint256") self._result.append(var) set_val(expression, val) else: # If tuple if expression.type_call.startswith( "tuple(") and expression.type_call != "tuple()": val = TupleVariable(self._node) else: val = TemporaryVariable(self._node) message_call = TmpCall(called, len(args), val, expression.type_call) message_call.set_expression(expression) # Gas/value are only accessible here if the syntax {gas: , value: } # Is used over .gas().value() if expression.call_gas: call_gas = get(expression.call_gas) message_call.call_gas = call_gas if expression.call_value: call_value = get(expression.call_value) message_call.call_value = call_value if expression.call_salt: call_salt = get(expression.call_salt) message_call.call_salt = call_salt self._result.append(message_call) set_val(expression, val)