def replace_with_value(node, var, value):
if node.value == "with" and node.args[0].value == var:
return LLLnode(node.value, [node.args[0], replace_with_value(node.args[1], var, value), node.args[2]],
node.typ, node.location, node.annotation)
elif node.value == var:
return LLLnode(value, [], node.typ, node.location, node.annotation)
else:
return LLLnode(node.value, [replace_with_value(arg, var, value) for arg in node.args], node.typ, node.location, node.annotation)
def ann_assign(self):
self.context.set_in_assignment(True)
typ = parse_type(self.stmt.annotation, location='memory', custom_units=self.context.custom_units, custom_structs=self.context.structs)
if isinstance(self.stmt.target, ast.Attribute):
raise TypeMismatchException('May not set type for field %r' % self.stmt.target.attr, self.stmt)
varname = self.stmt.target.id
pos = self.context.new_variable(varname, typ)
o = LLLnode.from_list('pass', typ=None, pos=pos)
if self.stmt.value is not None:
sub = Expr(self.stmt.value, self.context).lll_node
# Disallow assignment to None
if isinstance(sub.typ, NullType):
raise InvalidLiteralException('Assignment to None is not allowed, use a default value or built-in `clear()`.', self.stmt)
# If bytes[32] to bytes32 assignment rewrite sub as bytes32.
if isinstance(sub.typ, ByteArrayType) and sub.typ.maxlen == 32 and isinstance(typ, BaseType) and typ.typ == 'bytes32':
bytez, bytez_length = string_to_bytes(self.stmt.value.s)
sub = LLLnode(bytes_to_int(bytez), typ=BaseType('bytes32'), pos=getpos(self.stmt))
self._check_valid_assign(sub)
self._check_same_variable_assign(sub)
variable_loc = LLLnode.from_list(pos, typ=typ, location='memory', pos=getpos(self.stmt))
o = make_setter(variable_loc, sub, 'memory', pos=getpos(self.stmt))
# o.pos = getpos(self.stmt) # TODO: Should this be here like in assign()?
self.context.set_in_assignment(False)
return o
def ann_assign(self):
self.context.set_in_assignment(True)
typ = parse_type(self.stmt.annotation,
location='memory',
custom_units=self.context.custom_units)
if isinstance(self.stmt.target,
ast.Attribute) and self.stmt.target.value.id == 'self':
raise TypeMismatchException('May not redefine storage variables.',
self.stmt)
varname = self.stmt.target.id
pos = self.context.new_variable(varname, typ)
o = LLLnode.from_list('pass', typ=None, pos=pos)
if self.stmt.value is not None:
sub = Expr(self.stmt.value, self.context).lll_node
# If bytes[32] to bytes32 assignment rewrite sub as bytes32.
if isinstance(
sub.typ,
ByteArrayType) and sub.typ.maxlen == 32 and isinstance(
typ, BaseType) and typ.typ == 'bytes32':
bytez, bytez_length = string_to_bytes(self.stmt.value.s)
sub = LLLnode(bytes_to_int(bytez),
typ=BaseType('bytes32'),
pos=getpos(self.stmt))
self._check_valid_assign(sub)
self._check_same_variable_assign(sub)
variable_loc = LLLnode.from_list(pos,
typ=typ,
location='memory',
pos=getpos(self.stmt))
o = make_setter(variable_loc, sub, 'memory', pos=getpos(self.stmt))
self.context.set_in_assignment(False)
return o
def to_bytes32(expr, args, kwargs, context):
input = args[0]
typ, len = get_type(input)
if typ == 'bytes':
if len != 32:
raise TypeMismatchException(
"Unable to convert bytes[{}] to bytes32".format(len))
if input.location == "memory":
return LLLnode.from_list(['mload', ['add', input, 32]],
typ=BaseType('bytes32'))
elif input.location == "storage":
return LLLnode.from_list(['sload', ['add', ['sha3_32', input], 1]],
typ=BaseType('bytes32'))
if input.typ.is_literal:
bytez = b''
for c in input:
if ord(c) >= 256:
raise InvalidLiteralException(
"Cannot insert special character %r into byte array" % c)
bytez += bytes([ord(c)])
return bytez
else:
return LLLnode(value=input.value,
args=input.args,
typ=BaseType('bytes32'),
pos=getpos(expr))
def parse_name(self):
if self.stmt.id == "vdb":
return LLLnode('debugger', typ=None, pos=getpos(self.stmt))
elif self.stmt.id == "throw":
return LLLnode.from_list(['assert', 0], typ=None, pos=getpos(self.stmt))
else:
raise StructureException("Unsupported statement type: %s" % type(self.stmt), self.stmt)
def to_address(expr, args, kwargs, context):
in_arg = args[0]
return LLLnode(value=in_arg.value,
args=in_arg.args,
typ=BaseType('address'),
pos=getpos(expr))
def to_bytes32(expr, args, kwargs, context):
in_arg = args[0]
input_type, _len = get_type(in_arg)
if input_type == 'bytes':
if _len > 32:
raise TypeMismatchException((
"Unable to convert bytes[{}] to bytes32, max length is too "
"large."
).format(len))
if in_arg.location == "memory":
return LLLnode.from_list(
['mload', ['add', in_arg, 32]],
typ=BaseType('bytes32')
)
elif in_arg.location == "storage":
return LLLnode.from_list(
['sload', ['add', ['sha3_32', in_arg], 1]],
typ=BaseType('bytes32')
)
else:
return LLLnode(
value=in_arg.value,
args=in_arg.args,
typ=BaseType('bytes32'),
pos=getpos(expr)
)
def as_unitless_number(expr, args, kwargs, context):
return LLLnode(
value=args[0].value,
args=args[0].args,
typ=BaseType(args[0].typ.typ, {}),
pos=getpos(expr),
)
def to_uint256(expr, args, kwargs, context):
in_node = args[0]
input_type, len = get_type(in_node)
if isinstance(in_node, int):
if not SizeLimits.in_bounds('uint256', in_node):
raise InvalidLiteralException(
"Number out of range: {}".format(in_node))
_unit = in_node.typ.unit if input_type == 'int128' else None
return LLLnode.from_list(in_node,
typ=BaseType('uint256', _unit),
pos=getpos(expr))
elif isinstance(in_node,
LLLnode) and input_type in ('int128', 'num_literal'):
_unit = in_node.typ.unit if input_type == 'int128' else None
return LLLnode.from_list(['clampge', in_node, 0],
typ=BaseType('uint256', _unit),
pos=getpos(expr))
elif isinstance(in_node, LLLnode) and input_type in ('bytes32', 'address'):
return LLLnode(value=in_node.value,
args=in_node.args,
typ=BaseType('uint256'),
pos=getpos(expr))
else:
raise InvalidLiteralException(
"Invalid input for uint256: %r" % in_node, expr)
def parse_AnnAssign(self):
typ = parse_type(
self.stmt.annotation, location="memory", custom_structs=self.context.structs,
)
varname = self.stmt.target.id
pos = self.context.new_variable(varname, typ, pos=self.stmt)
if self.stmt.value is None:
return
sub = Expr(self.stmt.value, self.context).lll_node
is_literal_bytes32_assign = (
isinstance(sub.typ, ByteArrayType)
and sub.typ.maxlen == 32
and isinstance(typ, BaseType)
and typ.typ == "bytes32"
and sub.typ.is_literal
)
# If bytes[32] to bytes32 assignment rewrite sub as bytes32.
if is_literal_bytes32_assign:
sub = LLLnode(
bytes_to_int(self.stmt.value.s), typ=BaseType("bytes32"), pos=getpos(self.stmt),
)
variable_loc = LLLnode.from_list(pos, typ=typ, location="memory", pos=getpos(self.stmt),)
lll_node = make_setter(variable_loc, sub, "memory", pos=getpos(self.stmt))
return lll_node
def to_uint256(expr, args, kwargs, context):
in_arg = args[0]
input_type, _ = get_type(in_arg)
_unit = in_arg.typ.unit if input_type in ('int128', 'decimal') else None
if input_type == 'num_literal':
if isinstance(in_arg, int):
if not SizeLimits.in_bounds('uint256', in_arg):
raise InvalidLiteralException(
"Number out of range: {}".format(in_arg))
return LLLnode.from_list(in_arg,
typ=BaseType('uint256', _unit),
pos=getpos(expr))
elif isinstance(in_arg, float):
if not SizeLimits.in_bounds('uint256', math.trunc(in_arg)):
raise InvalidLiteralException("Number out of range: {}".format(
math.trunc(in_arg)))
return LLLnode.from_list(math.trunc(in_arg),
typ=BaseType('uint256', _unit),
pos=getpos(expr))
else:
raise InvalidLiteralException(
"Unknown numeric literal type: {}".fornat(in_arg))
elif isinstance(in_arg, LLLnode) and input_type == 'int128':
return LLLnode.from_list(['clampge', in_arg, 0],
typ=BaseType('uint256', _unit),
pos=getpos(expr))
elif isinstance(in_arg, LLLnode) and input_type == 'decimal':
return LLLnode.from_list(
['div', ['clampge', in_arg, 0], DECIMAL_DIVISOR],
typ=BaseType('uint256', _unit),
pos=getpos(expr))
elif isinstance(in_arg, LLLnode) and input_type == 'bool':
return LLLnode.from_list(in_arg,
typ=BaseType('uint256'),
pos=getpos(expr))
elif isinstance(in_arg, LLLnode) and input_type in ('bytes32', 'address'):
return LLLnode(value=in_arg.value,
args=in_arg.args,
typ=BaseType('uint256'),
pos=getpos(expr))
elif isinstance(in_arg, LLLnode) and input_type == 'bytes':
if in_arg.typ.maxlen > 32:
raise InvalidLiteralException(
"Cannot convert bytes array of max length {} to uint256".
format(in_arg.value),
expr,
)
return byte_array_to_num(in_arg, expr, 'uint256')
else:
raise InvalidLiteralException("Invalid input for uint256: %r" % in_arg,
expr)
def ann_assign(self):
with self.context.assignment_scope():
typ = parse_type(
self.stmt.annotation,
location='memory',
custom_units=self.context.custom_units,
custom_structs=self.context.structs,
constants=self.context.constants,
)
if isinstance(self.stmt.target, ast.Attribute):
raise TypeMismatchException(
f'May not set type for field {self.stmt.target.attr}',
self.stmt,
)
varname = self.stmt.target.id
pos = self.context.new_variable(varname, typ)
o = LLLnode.from_list('pass', typ=None, pos=pos)
if self.stmt.value is None:
raise StructureException(
'New variables must be initialized explicitly',
self.stmt)
sub = Expr(self.stmt.value, self.context).lll_node
# Disallow assignment to None
if isinstance(sub.typ, NullType):
raise InvalidLiteralException(
(
'Assignment to None is not allowed, use a default '
'value or built-in `clear()`.'
),
self.stmt
)
is_valid_bytes32_assign = (
isinstance(sub.typ, ByteArrayType) and sub.typ.maxlen == 32
) and isinstance(typ, BaseType) and typ.typ == 'bytes32'
# If bytes[32] to bytes32 assignment rewrite sub as bytes32.
if is_valid_bytes32_assign:
sub = LLLnode(
bytes_to_int(self.stmt.value.s),
typ=BaseType('bytes32'),
pos=getpos(self.stmt),
)
self._check_valid_assign(sub)
self._check_same_variable_assign(sub)
variable_loc = LLLnode.from_list(
pos,
typ=typ,
location='memory',
pos=getpos(self.stmt),
)
o = make_setter(variable_loc, sub, 'memory', pos=getpos(self.stmt))
# o.pos = getpos(self.stmt) # TODO: Should this be here like in assign()?
return o
def to_bytes(expr, args, kwargs, context):
in_arg = args[0]
if in_arg.typ.maxlen > args[1].slice.value.n:
raise TypeMismatchException(
'Cannot convert as input bytes are larger than max length', expr)
return LLLnode(value=in_arg.value,
args=in_arg.args,
typ=ByteArrayType(in_arg.typ.maxlen),
pos=getpos(expr),
location=in_arg.location)
def to_uint256(expr, args, kwargs, context):
in_arg = args[0]
input_type, _ = get_type(in_arg)
if input_type == "num_literal":
if isinstance(in_arg, int):
if not SizeLimits.in_bounds("uint256", in_arg):
raise InvalidLiteral(f"Number out of range: {in_arg}")
return LLLnode.from_list(in_arg,
typ=BaseType("uint256", ),
pos=getpos(expr))
elif isinstance(in_arg, Decimal):
if not SizeLimits.in_bounds("uint256", math.trunc(in_arg)):
raise InvalidLiteral(
f"Number out of range: {math.trunc(in_arg)}")
return LLLnode.from_list(math.trunc(in_arg),
typ=BaseType("uint256"),
pos=getpos(expr))
else:
raise InvalidLiteral(f"Unknown numeric literal type: {in_arg}")
elif isinstance(in_arg, LLLnode) and input_type == "int128":
return LLLnode.from_list(["clampge", in_arg, 0],
typ=BaseType("uint256"),
pos=getpos(expr))
elif isinstance(in_arg, LLLnode) and input_type == "decimal":
return LLLnode.from_list(
["div", ["clampge", in_arg, 0], DECIMAL_DIVISOR],
typ=BaseType("uint256"),
pos=getpos(expr),
)
elif isinstance(in_arg, LLLnode) and input_type == "bool":
return LLLnode.from_list(in_arg,
typ=BaseType("uint256"),
pos=getpos(expr))
elif isinstance(in_arg, LLLnode) and input_type in ("bytes32", "address"):
return LLLnode(value=in_arg.value,
args=in_arg.args,
typ=BaseType("uint256"),
pos=getpos(expr))
elif isinstance(in_arg, LLLnode) and input_type == "Bytes":
if in_arg.typ.maxlen > 32:
raise InvalidLiteral(
f"Cannot convert bytes array of max length {in_arg.typ.maxlen} to uint256",
expr,
)
return byte_array_to_num(in_arg, expr, "uint256")
else:
raise InvalidLiteral(f"Invalid input for uint256: {in_arg}", expr)
def to_uint256(expr, args, kwargs, context):
input = args[0]
typ, len = get_type(input)
if isinstance(input, int):
if not(0 <= input <= 2**256 - 1):
raise InvalidLiteralException("Number out of range: {}".format(input))
return LLLnode.from_list(input, typ=BaseType('uint256'), pos=getpos(expr))
elif isinstance(input, LLLnode) and typ in ('int128', 'num_literal'):
return LLLnode.from_list(['clampge', input, 0], typ=BaseType('uint256'), pos=getpos(expr))
elif isinstance(input, LLLnode) and typ in ('bytes32'):
return LLLnode(value=input.value, args=input.args, typ=BaseType('uint256'), pos=getpos(expr))
else:
raise InvalidLiteralException("Invalid input for uint256: %r" % input, expr)
def ann_assign(self):
with self.context.assignment_scope():
typ = parse_type(
self.stmt.annotation,
location='memory',
custom_structs=self.context.structs,
constants=self.context.constants,
)
if isinstance(self.stmt.target, vy_ast.Attribute):
raise TypeMismatch(
f'May not set type for field {self.stmt.target.attr}',
self.stmt,
)
varname = self.stmt.target.id
pos = self.context.new_variable(varname, typ)
if self.stmt.value is None:
raise StructureException(
'New variables must be initialized explicitly',
self.stmt)
sub = Expr(self.stmt.value, self.context).lll_node
is_literal_bytes32_assign = (
isinstance(sub.typ, ByteArrayType)
and sub.typ.maxlen == 32
and isinstance(typ, BaseType)
and typ.typ == 'bytes32'
and sub.typ.is_literal
)
# If bytes[32] to bytes32 assignment rewrite sub as bytes32.
if is_literal_bytes32_assign:
sub = LLLnode(
bytes_to_int(self.stmt.value.s),
typ=BaseType('bytes32'),
pos=getpos(self.stmt),
)
self._check_valid_assign(sub)
self._check_same_variable_assign(sub)
variable_loc = LLLnode.from_list(
pos,
typ=typ,
location='memory',
pos=getpos(self.stmt),
)
o = make_setter(variable_loc, sub, 'memory', pos=getpos(self.stmt))
return o
def method_id(expr, args, kwargs, context):
if b' ' in args[0]:
raise TypeMismatchException('Invalid function signature no spaces allowed.')
method_id = fourbytes_to_int(sha3(args[0])[:4])
if args[1] == 'bytes32':
return LLLnode(method_id, typ=BaseType('bytes32'), pos=getpos(expr))
elif args[1] == 'bytes[4]':
placeholder = LLLnode.from_list(context.new_placeholder(ByteArrayType(4)))
return LLLnode.from_list(
['seq',
['mstore', ['add', placeholder, 4], method_id],
['mstore', placeholder, 4], placeholder],
typ=ByteArrayType(4), location='memory', pos=getpos(expr))
else:
raise StructureException('Can only produce bytes32 or bytes[4] as outputs')
def to_bytes32(expr, args, kwargs, context):
input = args[0]
typ, len = get_type(input)
if typ == 'bytes':
if len != 32:
raise TypeMismatchException("Unable to convert bytes[{}] to bytes32".format(len))
if input.location == "memory":
return LLLnode.from_list(
['mload', ['add', input, 32]], typ=BaseType('bytes32')
)
elif input.location == "storage":
return LLLnode.from_list(
['sload', ['add', ['sha3_32', input], 1]], typ=BaseType('bytes32')
)
else:
return LLLnode(value=input.value, args=input.args, typ=BaseType('bytes32'), pos=getpos(expr))
def _to_bytelike(expr, args, kwargs, context, bytetype):
if bytetype == 'string':
ReturnType = StringType
elif bytetype == 'bytes':
ReturnType = ByteArrayType
else:
raise TypeMismatchException(f'Invalid {bytetype} supplied')
in_arg = args[0]
if in_arg.typ.maxlen > args[1].slice.value.n:
raise TypeMismatchException(
f'Cannot convert as input {bytetype} are larger than max length',
expr,
)
return LLLnode(value=in_arg.value,
args=in_arg.args,
typ=ReturnType(in_arg.typ.maxlen),
pos=getpos(expr),
location=in_arg.location)
def to_bytes32(expr, args, kwargs, context):
in_arg = args[0]
input_type, _len = get_type(in_arg)
if input_type == "Bytes":
if _len > 32:
raise TypeMismatch(
f"Unable to convert bytes[{_len}] to bytes32, max length is too " "large."
)
if in_arg.location == "memory":
return LLLnode.from_list(["mload", ["add", in_arg, 32]], typ=BaseType("bytes32"))
elif in_arg.location == "storage":
return LLLnode.from_list(
["sload", ["add", ["sha3_32", in_arg], 1]], typ=BaseType("bytes32")
)
else:
return LLLnode(
value=in_arg.value, args=in_arg.args, typ=BaseType("bytes32"), pos=getpos(expr)
)
def as_num256(expr, args, kwargs, context):
if isinstance(args[0], int):
if not (0 <= args[0] <= 2**256 - 1):
raise InvalidLiteralException(
"Number out of range: " + str(expr.args[0].n), expr.args[0])
return LLLnode.from_list(args[0],
typ=BaseType('num256'),
pos=getpos(expr))
elif isinstance(
args[0],
LLLnode) and args[0].typ.typ in ('num', 'num_literal', 'address'):
return LLLnode.from_list(['clampge', args[0], 0],
typ=BaseType('num256'),
pos=getpos(expr))
elif isinstance(args[0], LLLnode):
return LLLnode(value=args[0].value,
args=args[0].args,
typ=BaseType('num256'),
pos=getpos(expr))
else:
raise InvalidLiteralException("Invalid input for num256: %r" % args[0],
expr)
def parse_return(self):
if self.context.return_type is None:
if self.stmt.value:
raise TypeMismatchException("Not expecting to return a value",
self.stmt)
return LLLnode.from_list(make_return_stmt(self.stmt, self.context,
0, 0),
typ=None,
pos=getpos(self.stmt),
valency=0)
if not self.stmt.value:
raise TypeMismatchException("Expecting to return a value",
self.stmt)
def zero_pad(bytez_placeholder, maxlen):
zero_padder = LLLnode.from_list(['pass'])
if maxlen > 0:
zero_pad_i = self.context.new_placeholder(
BaseType('uint256')) # Iterator used to zero pad memory.
zero_padder = LLLnode.from_list(
[
'with',
'_ceil32_end',
['ceil32', ['mload', bytez_placeholder]],
[
'repeat',
zero_pad_i,
['mload', bytez_placeholder],
maxlen,
[
'seq',
[
'if',
[
'gt', ['mload', zero_pad_i],
'_ceil32_end'
], 'break'
], # stay within allocated bounds
[
'mstore8',
[
'add', ['add', 32, bytez_placeholder],
['mload', zero_pad_i]
], 0
]
]
]
],
annotation="Zero pad")
return zero_padder
sub = Expr(self.stmt.value, self.context).lll_node
self.context.increment_return_counter()
# Returning a value (most common case)
if isinstance(sub.typ, BaseType):
sub = unwrap_location(sub)
if not isinstance(self.context.return_type, BaseType):
raise TypeMismatchException(
"Return type units mismatch %r %r" %
(sub.typ, self.context.return_type), self.stmt.value)
elif self.context.return_type != sub.typ and not sub.typ.is_literal:
raise TypeMismatchException(
"Trying to return base type %r, output expecting %r" %
(sub.typ, self.context.return_type), self.stmt.value)
elif sub.typ.is_literal and (
self.context.return_type.typ == sub.typ or 'int'
in self.context.return_type.typ and 'int' in sub.typ.typ):
if not SizeLimits.in_bounds(self.context.return_type.typ,
sub.value):
raise InvalidLiteralException(
"Number out of range: " + str(sub.value), self.stmt)
else:
return LLLnode.from_list([
'seq', ['mstore', 0, sub],
make_return_stmt(self.stmt, self.context, 0, 32)
],
typ=None,
pos=getpos(self.stmt),
valency=0)
elif is_base_type(sub.typ, self.context.return_type.typ) or \
(is_base_type(sub.typ, 'int128') and is_base_type(self.context.return_type, 'int256')):
return LLLnode.from_list([
'seq', ['mstore', 0, sub],
make_return_stmt(self.stmt, self.context, 0, 32)
],
typ=None,
pos=getpos(self.stmt),
valency=0)
else:
raise TypeMismatchException(
"Unsupported type conversion: %r to %r" %
(sub.typ, self.context.return_type), self.stmt.value)
# Returning a byte array
elif isinstance(sub.typ, ByteArrayLike):
if not sub.typ.eq_base(self.context.return_type):
raise TypeMismatchException(
"Trying to return base type %r, output expecting %r" %
(sub.typ, self.context.return_type), self.stmt.value)
if sub.typ.maxlen > self.context.return_type.maxlen:
raise TypeMismatchException(
"Cannot cast from greater max-length %d to shorter max-length %d"
% (sub.typ.maxlen, self.context.return_type.maxlen),
self.stmt.value)
loop_memory_position = self.context.new_placeholder(
typ=BaseType(
'uint256')) # loop memory has to be allocated first.
len_placeholder = self.context.new_placeholder(
typ=BaseType('uint256')
) # len & bytez placeholder have to be declared after each other at all times.
bytez_placeholder = self.context.new_placeholder(typ=sub.typ)
if sub.location in ('storage', 'memory'):
return LLLnode.from_list([
'seq',
make_byte_array_copier(LLLnode(
bytez_placeholder, location='memory', typ=sub.typ),
sub,
pos=getpos(self.stmt)),
zero_pad(bytez_placeholder, sub.typ.maxlen),
['mstore', len_placeholder, 32],
make_return_stmt(
self.stmt,
self.context,
len_placeholder,
['ceil32', ['add', ['mload', bytez_placeholder], 64]],
loop_memory_position=loop_memory_position)
],
typ=None,
pos=getpos(self.stmt),
valency=0)
else:
raise Exception("Invalid location: %s" % sub.location)
elif isinstance(sub.typ, ListType):
sub_base_type = re.split(r'\(|\[', str(sub.typ.subtype))[0]
ret_base_type = re.split(r'\(|\[',
str(self.context.return_type.subtype))[0]
loop_memory_position = self.context.new_placeholder(
typ=BaseType('uint256'))
if sub_base_type != ret_base_type:
raise TypeMismatchException(
"List return type %r does not match specified return type, expecting %r"
% (sub_base_type, ret_base_type), self.stmt)
elif sub.location == "memory" and sub.value != "multi":
return LLLnode.from_list(make_return_stmt(
self.stmt,
self.context,
sub,
get_size_of_type(self.context.return_type) * 32,
loop_memory_position=loop_memory_position),
typ=None,
pos=getpos(self.stmt),
valency=0)
else:
new_sub = LLLnode.from_list(self.context.new_placeholder(
self.context.return_type),
typ=self.context.return_type,
location='memory')
setter = make_setter(new_sub,
sub,
'memory',
pos=getpos(self.stmt))
return LLLnode.from_list([
'seq', setter,
make_return_stmt(
self.stmt,
self.context,
new_sub,
get_size_of_type(self.context.return_type) * 32,
loop_memory_position=loop_memory_position)
],
typ=None,
pos=getpos(self.stmt))
# Returning a struct
elif isinstance(sub.typ, StructType):
retty = self.context.return_type
if not isinstance(retty, StructType) or retty.name != sub.typ.name:
raise TypeMismatchException(
"Trying to return %r, output expecting %r" %
(sub.typ, self.context.return_type), self.stmt.value)
return gen_tuple_return(self.stmt, self.context, sub)
# Returning a tuple.
elif isinstance(sub.typ, TupleType):
if not isinstance(self.context.return_type, TupleType):
raise TypeMismatchException(
"Trying to return tuple type %r, output expecting %r" %
(sub.typ, self.context.return_type), self.stmt.value)
if len(self.context.return_type.members) != len(sub.typ.members):
raise StructureException("Tuple lengths don't match!",
self.stmt)
# check return type matches, sub type.
for i, ret_x in enumerate(self.context.return_type.members):
s_member = sub.typ.members[i]
sub_type = s_member if isinstance(s_member,
NodeType) else s_member.typ
if type(sub_type) is not type(ret_x):
raise StructureException(
"Tuple return type does not match annotated return. {} != {}"
.format(type(sub_type), type(ret_x)), self.stmt)
return gen_tuple_return(self.stmt, self.context, sub)
else:
raise TypeMismatchException("Can't return type %r" % sub.typ,
self.stmt)
def method_id(expr, args, kwargs, context):
method_id = fourbytes_to_int(sha3(args[0])[:4])
return LLLnode(method_id, typ=BaseType('method_id'), pos=getpos(expr))
def as_bytes32(expr, args, kwargs, context):
return LLLnode(value=args[0].value,
args=args[0].args,
typ=BaseType('bytes32'),
pos=getpos(expr))
def parse_name(self):
if self.stmt.id == "vdb":
return LLLnode('debugger', typ=None, pos=getpos(self.stmt))
else:
raise StructureException(
f"Unsupported statement type: {type(self.stmt)}", self.stmt)
def parse_return(self):
if self.context.return_type is None:
if self.stmt.value:
raise TypeMismatchException("Not expecting to return a value",
self.stmt)
return LLLnode.from_list(
make_return_stmt(self.stmt, self.context, 0, 0),
typ=None,
pos=getpos(self.stmt),
valency=0,
)
if not self.stmt.value:
raise TypeMismatchException("Expecting to return a value",
self.stmt)
sub = Expr(self.stmt.value, self.context).lll_node
# Returning a value (most common case)
if isinstance(sub.typ, BaseType):
sub = unwrap_location(sub)
if not isinstance(self.context.return_type, BaseType):
raise TypeMismatchException(
f"Return type units mismatch {sub.typ} {self.context.return_type}",
self.stmt.value)
elif self.context.return_type != sub.typ and not sub.typ.is_literal:
raise TypeMismatchException(
f"Trying to return base type {sub.typ}, output expecting "
f"{self.context.return_type}",
self.stmt.value,
)
elif sub.typ.is_literal and (
self.context.return_type.typ == sub.typ
or 'int' in self.context.return_type.typ
and 'int' in sub.typ.typ): # noqa: E501
if not SizeLimits.in_bounds(self.context.return_type.typ,
sub.value):
raise InvalidLiteralException(
"Number out of range: " + str(sub.value), self.stmt)
else:
return LLLnode.from_list(
[
'seq', ['mstore', 0, sub],
make_return_stmt(self.stmt, self.context, 0, 32)
],
typ=None,
pos=getpos(self.stmt),
valency=0,
)
elif is_base_type(sub.typ, self.context.return_type.typ) or (
is_base_type(sub.typ, 'int128') and is_base_type(
self.context.return_type, 'int256')): # noqa: E501
return LLLnode.from_list(
[
'seq', ['mstore', 0, sub],
make_return_stmt(self.stmt, self.context, 0, 32)
],
typ=None,
pos=getpos(self.stmt),
valency=0,
)
else:
raise TypeMismatchException(
f"Unsupported type conversion: {sub.typ} to {self.context.return_type}",
self.stmt.value,
)
# Returning a byte array
elif isinstance(sub.typ, ByteArrayLike):
if not sub.typ.eq_base(self.context.return_type):
raise TypeMismatchException(
f"Trying to return base type {sub.typ}, output expecting "
f"{self.context.return_type}",
self.stmt.value,
)
if sub.typ.maxlen > self.context.return_type.maxlen:
raise TypeMismatchException(
f"Cannot cast from greater max-length {sub.typ.maxlen} to shorter "
f"max-length {self.context.return_type.maxlen}",
self.stmt.value,
)
# loop memory has to be allocated first.
loop_memory_position = self.context.new_placeholder(
typ=BaseType('uint256'))
# len & bytez placeholder have to be declared after each other at all times.
len_placeholder = self.context.new_placeholder(
typ=BaseType('uint256'))
bytez_placeholder = self.context.new_placeholder(typ=sub.typ)
if sub.location in ('storage', 'memory'):
return LLLnode.from_list([
'seq',
make_byte_array_copier(LLLnode(
bytez_placeholder, location='memory', typ=sub.typ),
sub,
pos=getpos(self.stmt)),
zero_pad(bytez_placeholder),
['mstore', len_placeholder, 32],
make_return_stmt(
self.stmt,
self.context,
len_placeholder,
['ceil32', ['add', ['mload', bytez_placeholder], 64]],
loop_memory_position=loop_memory_position,
)
],
typ=None,
pos=getpos(self.stmt),
valency=0)
else:
raise Exception(f"Invalid location: {sub.location}")
elif isinstance(sub.typ, ListType):
sub_base_type = re.split(r'\(|\[', str(sub.typ.subtype))[0]
ret_base_type = re.split(r'\(|\[',
str(self.context.return_type.subtype))[0]
loop_memory_position = self.context.new_placeholder(
typ=BaseType('uint256'))
if sub_base_type != ret_base_type:
raise TypeMismatchException(
f"List return type {sub_base_type} does not match specified "
f"return type, expecting {ret_base_type}", self.stmt)
elif sub.location == "memory" and sub.value != "multi":
return LLLnode.from_list(
make_return_stmt(
self.stmt,
self.context,
sub,
get_size_of_type(self.context.return_type) * 32,
loop_memory_position=loop_memory_position,
),
typ=None,
pos=getpos(self.stmt),
valency=0,
)
else:
new_sub = LLLnode.from_list(
self.context.new_placeholder(self.context.return_type),
typ=self.context.return_type,
location='memory',
)
setter = make_setter(new_sub,
sub,
'memory',
pos=getpos(self.stmt))
return LLLnode.from_list([
'seq', setter,
make_return_stmt(
self.stmt,
self.context,
new_sub,
get_size_of_type(self.context.return_type) * 32,
loop_memory_position=loop_memory_position,
)
],
typ=None,
pos=getpos(self.stmt))
# Returning a struct
elif isinstance(sub.typ, StructType):
retty = self.context.return_type
if not isinstance(retty, StructType) or retty.name != sub.typ.name:
raise TypeMismatchException(
f"Trying to return {sub.typ}, output expecting {self.context.return_type}",
self.stmt.value,
)
return gen_tuple_return(self.stmt, self.context, sub)
# Returning a tuple.
elif isinstance(sub.typ, TupleType):
if not isinstance(self.context.return_type, TupleType):
raise TypeMismatchException(
f"Trying to return tuple type {sub.typ}, output expecting "
f"{self.context.return_type}",
self.stmt.value,
)
if len(self.context.return_type.members) != len(sub.typ.members):
raise StructureException("Tuple lengths don't match!",
self.stmt)
# check return type matches, sub type.
for i, ret_x in enumerate(self.context.return_type.members):
s_member = sub.typ.members[i]
sub_type = s_member if isinstance(s_member,
NodeType) else s_member.typ
if type(sub_type) is not type(ret_x):
raise StructureException(
"Tuple return type does not match annotated return. "
f"{type(sub_type)} != {type(ret_x)}", self.stmt)
return gen_tuple_return(self.stmt, self.context, sub)
else:
raise TypeMismatchException(f"Can't return type {sub.typ}",
self.stmt)
def optimize(node: LLLnode) -> LLLnode:
argz = [optimize(arg) for arg in node.args]
if node.value in arith and int_at(argz, 0) and int_at(argz, 1):
left, right = get_int_at(argz, 0), get_int_at(argz, 1)
calcer, symb = arith[node.value]
new_value = calcer(left, right)
if argz[0].annotation and argz[1].annotation:
annotation = argz[0].annotation + symb + argz[1].annotation
elif argz[0].annotation or argz[1].annotation:
annotation = (argz[0].annotation or str(left)) + symb + (
argz[1].annotation or str(right))
else:
annotation = ''
return LLLnode(
new_value,
[],
node.typ,
None,
node.pos,
annotation,
add_gas_estimate=node.add_gas_estimate,
valency=node.valency,
)
elif _is_constant_add(node, argz):
calcer, symb = arith[node.value]
if argz[0].annotation and argz[1].args[0].annotation:
annotation = argz[0].annotation + symb + argz[1].args[0].annotation
elif argz[0].annotation or argz[1].args[0].annotation:
annotation = (argz[0].annotation or str(argz[0].value)) + symb + (
argz[1].args[0].annotation or str(argz[1].args[0].value))
else:
annotation = ''
return LLLnode(
"add",
[
LLLnode(argz[0].value + argz[1].args[0].value,
annotation=annotation),
argz[1].args[1],
],
node.typ,
None,
node.annotation,
add_gas_estimate=node.add_gas_estimate,
valency=node.valency,
)
elif node.value == "add" and get_int_at(argz, 0) == 0:
return LLLnode(
argz[1].value,
argz[1].args,
node.typ,
node.location,
node.pos,
argz[1].annotation,
add_gas_estimate=node.add_gas_estimate,
valency=node.valency,
)
elif node.value == "add" and get_int_at(argz, 1) == 0:
return LLLnode(
argz[0].value,
argz[0].args,
node.typ,
node.location,
node.pos,
argz[0].annotation,
add_gas_estimate=node.add_gas_estimate,
valency=node.valency,
)
elif node.value == "clamp" and int_at(argz, 0) and int_at(
argz, 1) and int_at(argz, 2):
if get_int_at(argz, 0, True) > get_int_at(argz, 1, True):
raise Exception("Clamp always fails")
elif get_int_at(argz, 1, True) > get_int_at(argz, 2, True):
raise Exception("Clamp always fails")
else:
return argz[1]
elif node.value == "clamp" and int_at(argz, 0) and int_at(argz, 1):
if get_int_at(argz, 0, True) > get_int_at(argz, 1, True):
raise Exception("Clamp always fails")
else:
return LLLnode(
"clample",
[argz[1], argz[2]],
node.typ,
node.location,
node.pos,
node.annotation,
add_gas_estimate=node.add_gas_estimate,
valency=node.valency,
)
elif node.value == "clamp_nonzero" and int_at(argz, 0):
if get_int_at(argz, 0) != 0:
return LLLnode(
argz[0].value,
[],
node.typ,
node.location,
node.pos,
node.annotation,
add_gas_estimate=node.add_gas_estimate,
valency=node.valency,
)
else:
raise Exception("Clamp always fails")
# [eq, x, 0] is the same as [iszero, x].
elif node.value == 'eq' and int_at(argz, 1) and argz[1].value == 0:
return LLLnode(
'iszero',
[argz[0]],
node.typ,
node.location,
node.pos,
node.annotation,
add_gas_estimate=node.add_gas_estimate,
valency=node.valency,
)
# [ne, x, y] has the same truthyness as [xor, x, y]
# rewrite 'ne' as 'xor' in places where truthy is accepted.
elif has_cond_arg(node) and argz[0].value == 'ne':
argz[0] = LLLnode.from_list(['xor'] + argz[0].args)
return LLLnode.from_list(
[node.value] + argz,
typ=node.typ,
location=node.location,
pos=node.pos,
annotation=node.annotation,
# let from_list handle valency and gas_estimate
)
elif _is_with_without_set(node, argz):
# TODO: This block is currently unreachable due to
# `_is_with_without_set` unconditionally returning `False` this appears
# to be because this "is actually not such a good optimization after
# all" accordiing to previous comment.
o = replace_with_value(argz[2], argz[0].value, argz[1].value)
return o
elif node.value == "seq":
o = []
for arg in argz:
if arg.value == "seq":
o.extend(arg.args)
elif arg.value != "pass":
o.append(arg)
return LLLnode(
node.value,
o,
node.typ,
node.location,
node.pos,
node.annotation,
add_gas_estimate=node.add_gas_estimate,
valency=node.valency,
)
elif node.total_gas is not None:
o = LLLnode(
node.value,
argz,
node.typ,
node.location,
node.pos,
node.annotation,
add_gas_estimate=node.add_gas_estimate,
valency=node.valency,
)
o.total_gas = node.total_gas - node.gas + o.gas
o.func_name = node.func_name
return o
else:
return LLLnode(
node.value,
argz,
node.typ,
node.location,
node.pos,
node.annotation,
add_gas_estimate=node.add_gas_estimate,
valency=node.valency,
)
def parse_return(self):
from .parser import (make_setter)
if self.context.return_type is None:
if self.stmt.value:
raise TypeMismatchException("Not expecting to return a value",
self.stmt)
return LLLnode.from_list(['return', 0, 0],
typ=None,
pos=getpos(self.stmt))
if not self.stmt.value:
raise TypeMismatchException("Expecting to return a value",
self.stmt)
sub = Expr(self.stmt.value, self.context).lll_node
self.context.increment_return_counter()
# Returning a value (most common case)
if isinstance(sub.typ, BaseType):
if not isinstance(self.context.return_type, BaseType):
raise TypeMismatchException(
"Trying to return base type %r, output expecting %r" %
(sub.typ, self.context.return_type), self.stmt.value)
sub = unwrap_location(sub)
if not are_units_compatible(sub.typ, self.context.return_type):
raise TypeMismatchException(
"Return type units mismatch %r %r" %
(sub.typ, self.context.return_type), self.stmt.value)
elif is_base_type(sub.typ, self.context.return_type.typ) or \
(is_base_type(sub.typ, 'int128') and is_base_type(self.context.return_type, 'int256')):
return LLLnode.from_list(
['seq', ['mstore', 0, sub], ['return', 0, 32]],
typ=None,
pos=getpos(self.stmt))
if sub.typ.is_literal and SizeLimits.in_bounds(
self.context.return_type.typ, sub.value):
return LLLnode.from_list(
['seq', ['mstore', 0, sub], ['return', 0, 32]],
typ=None,
pos=getpos(self.stmt))
else:
raise TypeMismatchException(
"Unsupported type conversion: %r to %r" %
(sub.typ, self.context.return_type), self.stmt.value)
# Returning a byte array
elif isinstance(sub.typ, ByteArrayType):
if not isinstance(self.context.return_type, ByteArrayType):
raise TypeMismatchException(
"Trying to return base type %r, output expecting %r" %
(sub.typ, self.context.return_type), self.stmt.value)
if sub.typ.maxlen > self.context.return_type.maxlen:
raise TypeMismatchException(
"Cannot cast from greater max-length %d to shorter max-length %d"
% (sub.typ.maxlen, self.context.return_type.maxlen),
self.stmt.value)
zero_padder = LLLnode.from_list(['pass'])
if sub.typ.maxlen > 0:
zero_pad_i = self.context.new_placeholder(
BaseType('uint256')) # Iterator used to zero pad memory.
zero_padder = LLLnode.from_list(
[
'repeat',
zero_pad_i,
['mload', '_loc'],
sub.typ.maxlen,
[
'seq',
[
'if',
['gt', ['mload', zero_pad_i], sub.typ.maxlen],
'break'
], # stay within allocated bounds
[
'mstore8',
[
'add', ['add', 32, '_loc'],
['mload', zero_pad_i]
], 0
]
]
],
annotation="Zero pad")
# Returning something already in memory
if sub.location == 'memory':
return LLLnode.from_list([
'with', '_loc', sub,
[
'seq', ['mstore', ['sub', '_loc', 32], 32],
zero_padder,
[
'return', ['sub', '_loc', 32],
['ceil32', ['add', ['mload', '_loc'], 64]]
]
]
],
typ=None,
pos=getpos(self.stmt))
# Copying from storage
elif sub.location == 'storage':
# Instantiate a byte array at some index
fake_byte_array = LLLnode(self.context.get_next_mem() + 32,
typ=sub.typ,
location='memory',
pos=getpos(self.stmt))
o = [
'with',
'_loc',
self.context.get_next_mem() + 32,
[
'seq',
# Copy the data to this byte array
make_byte_array_copier(fake_byte_array, sub),
# Store the number 32 before it for ABI formatting purposes
['mstore', self.context.get_next_mem(), 32],
zero_padder,
# Return it
[
'return',
self.context.get_next_mem(),
[
'add',
[
'ceil32',
[
'mload',
self.context.get_next_mem() + 32
]
], 64
]
]
]
]
return LLLnode.from_list(o, typ=None, pos=getpos(self.stmt))
else:
raise Exception("Invalid location: %s" % sub.location)
elif isinstance(sub.typ, ListType):
sub_base_type = re.split(r'\(|\[', str(sub.typ.subtype))[0]
ret_base_type = re.split(r'\(|\[',
str(self.context.return_type.subtype))[0]
if sub_base_type != ret_base_type:
raise TypeMismatchException(
"List return type %r does not match specified return type, expecting %r"
% (sub_base_type, ret_base_type), self.stmt)
elif sub.location == "memory" and sub.value != "multi":
return LLLnode.from_list([
'return', sub,
get_size_of_type(self.context.return_type) * 32
],
typ=None,
pos=getpos(self.stmt))
else:
new_sub = LLLnode.from_list(self.context.new_placeholder(
self.context.return_type),
typ=self.context.return_type,
location='memory')
setter = make_setter(new_sub,
sub,
'memory',
pos=getpos(self.stmt))
return LLLnode.from_list([
'seq', setter,
[
'return', new_sub,
get_size_of_type(self.context.return_type) * 32
]
],
typ=None,
pos=getpos(self.stmt))
# Returning a tuple.
elif isinstance(sub.typ, TupleType):
if len(self.context.return_type.members) != len(sub.typ.members):
raise StructureException("Tuple lengths don't match!",
self.stmt)
subs = []
dynamic_offset_counter = LLLnode(
self.context.get_next_mem(),
typ=None,
annotation="dynamic_offset_counter"
) # dynamic offset position counter.
new_sub = LLLnode.from_list(self.context.get_next_mem() + 32,
typ=self.context.return_type,
location='memory',
annotation='new_sub')
keyz = list(range(len(sub.typ.members)))
dynamic_offset_start = 32 * len(
sub.args) # The static list of args end.
left_token = LLLnode.from_list('_loc',
typ=new_sub.typ,
location="memory")
def get_dynamic_offset_value():
# Get value of dynamic offset counter.
return ['mload', dynamic_offset_counter]
def increment_dynamic_offset(dynamic_spot):
# Increment dyanmic offset counter in memory.
return [
'mstore', dynamic_offset_counter,
[
'add',
['add', ['ceil32', ['mload', dynamic_spot]], 32],
['mload', dynamic_offset_counter]
]
]
for i, typ in enumerate(keyz):
arg = sub.args[i]
variable_offset = LLLnode.from_list(
['add', 32 * i, left_token],
typ=arg.typ,
annotation='variable_offset')
if isinstance(arg.typ, ByteArrayType):
# Store offset pointer value.
subs.append([
'mstore', variable_offset,
get_dynamic_offset_value()
])
# Store dynamic data, from offset pointer onwards.
dynamic_spot = LLLnode.from_list(
['add', left_token,
get_dynamic_offset_value()],
location="memory",
typ=arg.typ,
annotation='dynamic_spot')
subs.append(
make_setter(dynamic_spot,
arg,
location="memory",
pos=getpos(self.stmt)))
subs.append(increment_dynamic_offset(dynamic_spot))
elif isinstance(arg.typ, BaseType):
subs.append(
make_setter(variable_offset,
arg,
"memory",
pos=getpos(self.stmt)))
else:
raise Exception("Can't return type %s as part of tuple",
type(arg.typ))
setter = LLLnode.from_list([
'seq', [
'mstore', dynamic_offset_counter, dynamic_offset_start
], ['with', '_loc', new_sub, ['seq'] + subs]
],
typ=None)
return LLLnode.from_list([
'seq', setter, ['return', new_sub,
get_dynamic_offset_value()]
],
typ=None,
pos=getpos(self.stmt))
else:
raise TypeMismatchException("Can only return base type!",
self.stmt)
def build_LLL(self, expr, args, kwargs, context):
output_type = context.parse_type(expr.args[0], expr.args[0])
return LLLnode(None, typ=output_type, pos=getpos(expr))
def parse_return(self):
if self.context.return_type is None:
if self.stmt.value:
raise TypeMismatchException("Not expecting to return a value",
self.stmt)
return LLLnode.from_list(self.make_return_stmt(0, 0),
typ=None,
pos=getpos(self.stmt),
valency=0)
if not self.stmt.value:
raise TypeMismatchException("Expecting to return a value",
self.stmt)
def zero_pad(bytez_placeholder, maxlen):
zero_padder = LLLnode.from_list(['pass'])
if maxlen > 0:
zero_pad_i = self.context.new_placeholder(
BaseType('uint256')) # Iterator used to zero pad memory.
zero_padder = LLLnode.from_list(
[
'repeat',
zero_pad_i,
['mload', bytez_placeholder],
maxlen,
[
'seq',
[
'if', ['gt', ['mload', zero_pad_i], maxlen],
'break'
], # stay within allocated bounds
[
'mstore8',
[
'add', ['add', 32, bytez_placeholder],
['mload', zero_pad_i]
], 0
]
]
],
annotation="Zero pad")
return zero_padder
sub = Expr(self.stmt.value, self.context).lll_node
self.context.increment_return_counter()
# Returning a value (most common case)
if isinstance(sub.typ, BaseType):
if not isinstance(self.context.return_type, BaseType):
raise TypeMismatchException(
"Trying to return base type %r, output expecting %r" %
(sub.typ, self.context.return_type), self.stmt.value)
sub = unwrap_location(sub)
if not are_units_compatible(sub.typ, self.context.return_type):
raise TypeMismatchException(
"Return type units mismatch %r %r" %
(sub.typ, self.context.return_type), self.stmt.value)
elif sub.typ.is_literal and (
self.context.return_type.typ == sub.typ or 'int'
in self.context.return_type.typ and 'int' in sub.typ.typ):
if not SizeLimits.in_bounds(self.context.return_type.typ,
sub.value):
raise InvalidLiteralException(
"Number out of range: " + str(sub.value), self.stmt)
else:
return LLLnode.from_list([
'seq', ['mstore', 0, sub],
self.make_return_stmt(0, 32)
],
typ=None,
pos=getpos(self.stmt),
valency=0)
elif is_base_type(sub.typ, self.context.return_type.typ) or \
(is_base_type(sub.typ, 'int128') and is_base_type(self.context.return_type, 'int256')):
return LLLnode.from_list(
['seq', ['mstore', 0, sub],
self.make_return_stmt(0, 32)],
typ=None,
pos=getpos(self.stmt),
valency=0)
else:
raise TypeMismatchException(
"Unsupported type conversion: %r to %r" %
(sub.typ, self.context.return_type), self.stmt.value)
# Returning a byte array
elif isinstance(sub.typ, ByteArrayType):
if not isinstance(self.context.return_type, ByteArrayType):
raise TypeMismatchException(
"Trying to return base type %r, output expecting %r" %
(sub.typ, self.context.return_type), self.stmt.value)
if sub.typ.maxlen > self.context.return_type.maxlen:
raise TypeMismatchException(
"Cannot cast from greater max-length %d to shorter max-length %d"
% (sub.typ.maxlen, self.context.return_type.maxlen),
self.stmt.value)
loop_memory_position = self.context.new_placeholder(
typ=BaseType(
'uint256')) # loop memory has to be allocated first.
len_placeholder = self.context.new_placeholder(
typ=BaseType('uint256')
) # len & bytez placeholder have to be declared after each other at all times.
bytez_placeholder = self.context.new_placeholder(typ=sub.typ)
if sub.location in ('storage', 'memory'):
return LLLnode.from_list([
'seq',
make_byte_array_copier(LLLnode(
bytez_placeholder, location='memory', typ=sub.typ),
sub,
pos=getpos(self.stmt)),
zero_pad(bytez_placeholder, sub.typ.maxlen),
['mstore', len_placeholder, 32],
self.make_return_stmt(
len_placeholder,
['ceil32', ['add', ['mload', bytez_placeholder], 64]],
loop_memory_position=loop_memory_position)
],
typ=None,
pos=getpos(self.stmt),
valency=0)
else:
raise Exception("Invalid location: %s" % sub.location)
elif isinstance(sub.typ, ListType):
sub_base_type = re.split(r'\(|\[', str(sub.typ.subtype))[0]
ret_base_type = re.split(r'\(|\[',
str(self.context.return_type.subtype))[0]
loop_memory_position = self.context.new_placeholder(
typ=BaseType('uint256'))
if sub_base_type != ret_base_type:
raise TypeMismatchException(
"List return type %r does not match specified return type, expecting %r"
% (sub_base_type, ret_base_type), self.stmt)
elif sub.location == "memory" and sub.value != "multi":
return LLLnode.from_list(self.make_return_stmt(
sub,
get_size_of_type(self.context.return_type) * 32,
loop_memory_position=loop_memory_position),
typ=None,
pos=getpos(self.stmt),
valency=0)
else:
new_sub = LLLnode.from_list(self.context.new_placeholder(
self.context.return_type),
typ=self.context.return_type,
location='memory')
setter = make_setter(new_sub,
sub,
'memory',
pos=getpos(self.stmt))
return LLLnode.from_list([
'seq', setter,
self.make_return_stmt(
new_sub,
get_size_of_type(self.context.return_type) * 32,
loop_memory_position=loop_memory_position)
],
typ=None,
pos=getpos(self.stmt))
# Returning a tuple.
elif isinstance(sub.typ, TupleType):
if not isinstance(self.context.return_type, TupleType):
raise TypeMismatchException(
"Trying to return tuple type %r, output expecting %r" %
(sub.typ, self.context.return_type), self.stmt.value)
if len(self.context.return_type.members) != len(sub.typ.members):
raise StructureException("Tuple lengths don't match!",
self.stmt)
# check return type matches, sub type.
for i, ret_x in enumerate(self.context.return_type.members):
s_member = sub.typ.members[i]
sub_type = s_member if isinstance(s_member,
NodeType) else s_member.typ
if type(sub_type) is not type(ret_x):
raise StructureException(
"Tuple return type does not match annotated return. {} != {}"
.format(type(sub_type), type(ret_x)), self.stmt)
# Is from a call expression.
if len(sub.args[0].args) > 0 and sub.args[0].args[
0].value == 'call': # self-call to public.
mem_pos = sub.args[0].args[-1]
mem_size = get_size_of_type(sub.typ) * 32
return LLLnode.from_list(['return', mem_pos, mem_size],
typ=sub.typ)
elif (sub.annotation and 'Internal Call' in sub.annotation):
mem_pos = sub.args[
-1].value if sub.value == 'seq_unchecked' else sub.args[
0].args[-1]
mem_size = get_size_of_type(sub.typ) * 32
# Add zero padder if bytes are present in output.
zero_padder = ['pass']
byte_arrays = [(i, x) for i, x in enumerate(sub.typ.members)
if isinstance(x, ByteArrayType)]
if byte_arrays:
i, x = byte_arrays[-1]
zero_padder = zero_pad(bytez_placeholder=[
'add', mem_pos, ['mload', mem_pos + i * 32]
],
maxlen=x.maxlen)
return LLLnode.from_list(
['seq'] + [sub] + [zero_padder] +
[self.make_return_stmt(mem_pos, mem_size)],
typ=sub.typ,
pos=getpos(self.stmt),
valency=0)
subs = []
# Pre-allocate loop_memory_position if required for private function returning.
loop_memory_position = self.context.new_placeholder(
typ=BaseType('uint256')) if self.context.is_private else None
# Allocate dynamic off set counter, to keep track of the total packed dynamic data size.
dynamic_offset_counter_placeholder = self.context.new_placeholder(
typ=BaseType('uint256'))
dynamic_offset_counter = LLLnode(
dynamic_offset_counter_placeholder,
typ=None,
annotation=
"dynamic_offset_counter" # dynamic offset position counter.
)
new_sub = LLLnode.from_list(
self.context.new_placeholder(typ=BaseType('uint256')),
typ=self.context.return_type,
location='memory',
annotation='new_sub')
keyz = list(range(len(sub.typ.members)))
dynamic_offset_start = 32 * len(
sub.args) # The static list of args end.
left_token = LLLnode.from_list('_loc',
typ=new_sub.typ,
location="memory")
def get_dynamic_offset_value():
# Get value of dynamic offset counter.
return ['mload', dynamic_offset_counter]
def increment_dynamic_offset(dynamic_spot):
# Increment dyanmic offset counter in memory.
return [
'mstore', dynamic_offset_counter,
[
'add',
['add', ['ceil32', ['mload', dynamic_spot]], 32],
['mload', dynamic_offset_counter]
]
]
for i, typ in enumerate(keyz):
arg = sub.args[i]
variable_offset = LLLnode.from_list(
['add', 32 * i, left_token],
typ=arg.typ,
annotation='variable_offset')
if isinstance(arg.typ, ByteArrayType):
# Store offset pointer value.
subs.append([
'mstore', variable_offset,
get_dynamic_offset_value()
])
# Store dynamic data, from offset pointer onwards.
dynamic_spot = LLLnode.from_list(
['add', left_token,
get_dynamic_offset_value()],
location="memory",
typ=arg.typ,
annotation='dynamic_spot')
subs.append(
make_setter(dynamic_spot,
arg,
location="memory",
pos=getpos(self.stmt)))
subs.append(increment_dynamic_offset(dynamic_spot))
elif isinstance(arg.typ, BaseType):
subs.append(
make_setter(variable_offset,
arg,
"memory",
pos=getpos(self.stmt)))
else:
raise Exception("Can't return type %s as part of tuple",
type(arg.typ))
setter = LLLnode.from_list([
'seq', [
'mstore', dynamic_offset_counter, dynamic_offset_start
], ['with', '_loc', new_sub, ['seq'] + subs]
],
typ=None)
return LLLnode.from_list([
'seq', setter,
self.make_return_stmt(new_sub, get_dynamic_offset_value(),
loop_memory_position)
],
typ=None,
pos=getpos(self.stmt),
valency=0)
else:
raise TypeMismatchException("Can only return base type!",
self.stmt)
