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):
loop_memory_position = self.context.new_placeholder(
typ=BaseType('uint256'))
if sub.typ != self.context.return_type:
raise TypeMismatchException(
f"List return type {sub.typ} does not match specified "
f"return type, expecting {self.context.return_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 pack_args_by_32(
holder,
maxlen,
arg,
typ,
context,
placeholder,
dynamic_offset_counter=None,
datamem_start=None,
pos=None,
):
"""
Copy necessary variables to pre-allocated memory section.
:param holder: Complete holder for all args
:param maxlen: Total length in bytes of the full arg section (static + dynamic).
:param arg: Current arg to pack
:param context: Context of arg
:param placeholder: Static placeholder for static argument part.
:param dynamic_offset_counter: position counter stored in static args.
:param dynamic_placeholder: pointer to current position in memory to write dynamic values to.
:param datamem_start: position where the whole datemem section starts.
"""
if isinstance(typ, BaseType):
if isinstance(arg, LLLnode):
value = unwrap_location(arg)
else:
value = Expr(arg, context).lll_node
value = base_type_conversion(value, value.typ, typ, pos)
holder.append(LLLnode.from_list(["mstore", placeholder, value], typ=typ, location="memory"))
elif isinstance(typ, ByteArrayLike):
if isinstance(arg, LLLnode): # Is prealloacted variable.
source_lll = arg
else:
source_lll = Expr(arg, context).lll_node
# Set static offset, in arg slot.
holder.append(LLLnode.from_list(["mstore", placeholder, ["mload", dynamic_offset_counter]]))
# Get the biginning to write the ByteArray to.
dest_placeholder = LLLnode.from_list(
["add", datamem_start, ["mload", dynamic_offset_counter]],
typ=typ,
location="memory",
annotation="pack_args_by_32:dest_placeholder",
)
copier = make_byte_array_copier(dest_placeholder, source_lll, pos=pos)
holder.append(copier)
# Add zero padding.
holder.append(zero_pad(dest_placeholder))
# Increment offset counter.
increment_counter = LLLnode.from_list(
[
"mstore",
dynamic_offset_counter,
[
"add",
[
"add",
["mload", dynamic_offset_counter],
["ceil32", ["mload", dest_placeholder]],
],
32,
],
],
annotation="Increment dynamic offset counter",
)
holder.append(increment_counter)
elif isinstance(typ, ListType):
if isinstance(arg, vy_ast.Call) and arg.func.get("id") == "empty":
# special case for `empty()` with a static-sized array
holder.append(mzero(placeholder, get_size_of_type(typ) * 32))
maxlen += (get_size_of_type(typ) - 1) * 32
return holder, maxlen
maxlen += (typ.count - 1) * 32
typ = typ.subtype
def check_list_type_match(provided): # Check list types match.
if provided != typ:
raise TypeMismatch(
f"Log list type '{provided}' does not match provided, expected '{typ}'"
)
# NOTE: Below code could be refactored into iterators/getter functions for each type of
# repetitive loop. But seeing how each one is a unique for loop, and in which way
# the sub value makes the difference in each type of list clearer.
# List from storage
if isinstance(arg, vy_ast.Attribute) and arg.value.id == "self":
stor_list = context.globals[arg.attr]
check_list_type_match(stor_list.typ.subtype)
size = stor_list.typ.count
mem_offset = 0
for i in range(0, size):
storage_offset = i
arg2 = LLLnode.from_list(
["sload", ["add", ["sha3_32", Expr(arg, context).lll_node], storage_offset]],
typ=typ,
)
holder, maxlen = pack_args_by_32(
holder, maxlen, arg2, typ, context, placeholder + mem_offset, pos=pos,
)
mem_offset += get_size_of_type(typ) * 32
# List from variable.
elif isinstance(arg, vy_ast.Name):
size = context.vars[arg.id].size
pos = context.vars[arg.id].pos
check_list_type_match(context.vars[arg.id].typ.subtype)
mem_offset = 0
for _ in range(0, size):
arg2 = LLLnode.from_list(
pos + mem_offset, typ=typ, location=context.vars[arg.id].location
)
holder, maxlen = pack_args_by_32(
holder, maxlen, arg2, typ, context, placeholder + mem_offset, pos=pos,
)
mem_offset += get_size_of_type(typ) * 32
# List from list literal.
else:
mem_offset = 0
for arg2 in arg.elements:
holder, maxlen = pack_args_by_32(
holder, maxlen, arg2, typ, context, placeholder + mem_offset, pos=pos,
)
mem_offset += get_size_of_type(typ) * 32
return holder, maxlen
def build_in_comparator(self):
left = Expr(self.expr.left, self.context).lll_node
right = Expr(self.expr.right, self.context).lll_node
result_placeholder = self.context.new_internal_variable(BaseType("bool"))
setter = []
# Load nth item from list in memory.
if right.value == "multi":
# Copy literal to memory to be compared.
tmp_list = LLLnode.from_list(
obj=self.context.new_internal_variable(
ListType(right.typ.subtype, right.typ.count)
),
typ=ListType(right.typ.subtype, right.typ.count),
location="memory",
)
setter = make_setter(tmp_list, right, "memory", pos=getpos(self.expr))
load_i_from_list = [
"mload",
["add", tmp_list, ["mul", 32, ["mload", MemoryPositions.FREE_LOOP_INDEX]]],
]
elif right.location == "storage":
load_i_from_list = [
"sload",
["add", ["sha3_32", right], ["mload", MemoryPositions.FREE_LOOP_INDEX]],
]
else:
load_operation = "mload" if right.location == "memory" else "calldataload"
load_i_from_list = [
load_operation,
["add", right, ["mul", 32, ["mload", MemoryPositions.FREE_LOOP_INDEX]]],
]
# Condition repeat loop has to break on.
break_loop_condition = [
"if",
["eq", unwrap_location(left), load_i_from_list],
["seq", ["mstore", "_result", 1], "break"], # store true.
]
# Repeat loop to loop-compare each item in the list.
for_loop_sequence = [
["mstore", result_placeholder, 0],
[
"with",
"_result",
result_placeholder,
[
"repeat",
MemoryPositions.FREE_LOOP_INDEX,
0,
right.typ.count,
break_loop_condition,
],
],
["mload", result_placeholder],
]
# Save list to memory, so one can iterate over it,
# used when literal was created with tmp_list.
if setter:
compare_sequence = ["seq", setter] + for_loop_sequence
else:
compare_sequence = ["seq"] + for_loop_sequence
if isinstance(self.expr.op, vy_ast.NotIn):
# for `not in`, invert the result
compare_sequence = ["iszero", compare_sequence]
return LLLnode.from_list(compare_sequence, typ="bool", annotation="in comparator")
def avo(arg, ind):
return unwrap_location(
add_variable_offset(arg, LLLnode.from_list(ind, 'num')))
def pack_logging_topics(event_id, args, expected_topics, context, pos):
topics = [event_id]
code_pos = pos
for pos, expected_topic in enumerate(expected_topics):
expected_type = expected_topic.typ
arg = args[pos]
value = Expr(arg, context).lll_node
arg_type = value.typ
if isinstance(arg_type, ByteArrayLike) and isinstance(expected_type, ByteArrayLike):
if arg_type.maxlen > expected_type.maxlen:
raise TypeMismatch(
f"Topic input bytes are too big: {arg_type} {expected_type}", code_pos
)
if isinstance(arg, (vy_ast.Str, vy_ast.Bytes)):
# for literals, generate the topic at compile time
value = arg.value
if isinstance(value, str):
value = value.encode()
topics.append(bytes_to_int(keccak256(value)))
elif value.location == "memory":
topics.append(["sha3", ["add", value, 32], ["mload", value]])
else:
# storage or calldata
placeholder = context.new_internal_variable(value.typ)
placeholder_node = LLLnode.from_list(placeholder, typ=value.typ, location="memory")
copier = make_byte_array_copier(
placeholder_node,
LLLnode.from_list("_sub", typ=value.typ, location=value.location),
)
lll_node = [
"with",
"_sub",
value,
["seq", copier, ["sha3", ["add", placeholder, 32], ["mload", placeholder]]],
]
topics.append(lll_node)
elif isinstance(arg_type, ListType) and isinstance(expected_type, ListType):
size = get_size_of_type(value.typ) * 32
if value.location == "memory":
topics.append(["sha3", value, size])
else:
# storage or calldata
placeholder = context.new_internal_variable(value.typ)
placeholder_node = LLLnode.from_list(placeholder, typ=value.typ, location="memory")
setter = make_setter(placeholder_node, value, "memory", value.pos)
lll_node = ["seq", setter, ["sha3", placeholder, size]]
topics.append(lll_node)
else:
if arg_type != expected_type:
raise TypeMismatch(
f"Invalid type for logging topic, got {arg_type} expected {expected_type}",
value.pos,
)
value = unwrap_location(value)
value = base_type_conversion(value, arg_type, expected_type, pos=code_pos)
topics.append(value)
return topics
def make_external_call(stmt_expr, context):
from vyper.parser.expr import Expr
value, gas = get_external_contract_keywords(stmt_expr, context)
if isinstance(stmt_expr.func, ast.Attribute) and isinstance(
stmt_expr.func.value, ast.Call):
contract_name = stmt_expr.func.value.func.id
contract_address = Expr.parse_value_expr(stmt_expr.func.value.args[0],
context)
return external_contract_call(
stmt_expr,
context,
contract_name,
contract_address,
pos=getpos(stmt_expr),
value=value,
gas=gas,
)
elif isinstance(
stmt_expr.func.value, ast.Attribute
) and stmt_expr.func.value.attr in context.sigs: # noqa: E501
contract_name = stmt_expr.func.value.attr
var = context.globals[stmt_expr.func.value.attr]
contract_address = unwrap_location(
LLLnode.from_list(
var.pos,
typ=var.typ,
location='storage',
pos=getpos(stmt_expr),
annotation='self.' + stmt_expr.func.value.attr,
))
return external_contract_call(
stmt_expr,
context,
contract_name,
contract_address,
pos=getpos(stmt_expr),
value=value,
gas=gas,
)
elif isinstance(
stmt_expr.func.value, ast.Attribute
) and stmt_expr.func.value.attr in context.globals: # noqa: E501
contract_name = context.globals[stmt_expr.func.value.attr].typ.unit
var = context.globals[stmt_expr.func.value.attr]
contract_address = unwrap_location(
LLLnode.from_list(
var.pos,
typ=var.typ,
location='storage',
pos=getpos(stmt_expr),
annotation='self.' + stmt_expr.func.value.attr,
))
return external_contract_call(
stmt_expr,
context,
contract_name,
contract_address,
pos=getpos(stmt_expr),
value=value,
gas=gas,
)
else:
raise StructureException(
"Unsupported operator: %r" % ast.dump(stmt_expr), stmt_expr)
def build_in_comparator(self):
from vyper.parser.parser import make_setter
left = Expr(self.expr.left, self.context).lll_node
right = Expr(self.expr.comparators[0], self.context).lll_node
if left.typ.typ != right.typ.subtype.typ:
raise TypeMismatchException("%s cannot be in a list of %s" %
(left.typ.typ, right.typ.subtype.typ))
result_placeholder = self.context.new_placeholder(BaseType('bool'))
setter = []
# Load nth item from list in memory.
if right.value == 'multi':
# Copy literal to memory to be compared.
tmp_list = LLLnode.from_list(obj=self.context.new_placeholder(
ListType(right.typ.subtype, right.typ.count)),
typ=ListType(right.typ.subtype,
right.typ.count),
location='memory')
setter = make_setter(tmp_list,
right,
'memory',
pos=getpos(self.expr))
load_i_from_list = [
'mload',
[
'add', tmp_list,
['mul', 32, ['mload', MemoryPositions.FREE_LOOP_INDEX]]
]
]
elif right.location == "storage":
load_i_from_list = [
'sload',
[
'add', ['sha3_32', right],
['mload', MemoryPositions.FREE_LOOP_INDEX]
]
]
else:
load_i_from_list = [
'mload',
[
'add', right,
['mul', 32, ['mload', MemoryPositions.FREE_LOOP_INDEX]]
]
]
# Condition repeat loop has to break on.
break_loop_condition = [
'if',
['eq', unwrap_location(left), load_i_from_list],
[
'seq',
['mstore', '_result', 1], # store true.
'break'
]
]
# Repeat loop to loop-compare each item in the list.
for_loop_sequence = [['mstore', result_placeholder, 0],
[
'with', '_result', result_placeholder,
[
'repeat', MemoryPositions.FREE_LOOP_INDEX,
0, right.typ.count, break_loop_condition
]
], ['mload', result_placeholder]]
# Save list to memory, so one can iterate over it,
# used when literal was created with tmp_list.
if setter:
compare_sequence = ['seq', setter] + for_loop_sequence
else:
compare_sequence = ['seq'] + for_loop_sequence
# Compare the result of the repeat loop to 1, to know if a match was found.
o = LLLnode.from_list(['eq', 1, compare_sequence],
typ='bool',
annotation="in comporator")
return o
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))
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))
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))
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)
)
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))
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 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))
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)
)
else:
raise TypeMismatchException("Can only return base type!", self.stmt)
def call(self):
from .parser import (
external_contract_call,
pack_arguments,
)
from vyper.functions import (
dispatch_table,
)
if isinstance(self.expr.func, ast.Name):
function_name = self.expr.func.id
if function_name in dispatch_table:
return dispatch_table[function_name](self.expr, self.context)
else:
err_msg = "Not a top-level function: {}".format(function_name)
if function_name in [x.split('(')[0] for x, _ in self.context.sigs['self'].items()]:
err_msg += ". Did you mean self.{}?".format(function_name)
raise StructureException(err_msg, self.expr)
elif isinstance(self.expr.func, ast.Attribute) and isinstance(self.expr.func.value, ast.Name) and self.expr.func.value.id == "self":
expr_args = [Expr(arg, self.context).lll_node for arg in self.expr.args]
method_name = self.expr.func.attr
sig = FunctionSignature.lookup_sig(self.context.sigs, method_name, expr_args, self.expr, self.context)
if self.context.is_constant and not sig.const:
raise ConstancyViolationException(
"May not call non-constant function '%s' within a constant function." % (method_name),
getpos(self.expr)
)
add_gas = sig.gas # gas of call
inargs, inargsize = pack_arguments(sig, expr_args, self.context, pos=getpos(self.expr))
output_placeholder = self.context.new_placeholder(typ=sig.output_type)
multi_arg = []
if isinstance(sig.output_type, BaseType):
returner = output_placeholder
elif isinstance(sig.output_type, ByteArrayType):
returner = output_placeholder + 32
elif isinstance(sig.output_type, TupleType):
returner = output_placeholder
else:
raise TypeMismatchException("Invalid output type: %r" % sig.output_type, self.expr)
o = LLLnode.from_list(multi_arg +
['seq',
['assert', ['call', ['gas'], ['address'], 0,
inargs, inargsize,
output_placeholder, get_size_of_type(sig.output_type) * 32]], returner],
typ=sig.output_type, location='memory',
pos=getpos(self.expr), add_gas_estimate=add_gas, annotation='Internal Call: %s' % method_name)
o.gas += sig.gas
return o
elif isinstance(self.expr.func, ast.Attribute) and isinstance(self.expr.func.value, ast.Call):
contract_name = self.expr.func.value.func.id
contract_address = Expr.parse_value_expr(self.expr.func.value.args[0], self.context)
value, gas = self._get_external_contract_keywords()
return external_contract_call(self.expr, self.context, contract_name, contract_address, pos=getpos(self.expr), value=value, gas=gas)
elif isinstance(self.expr.func.value, ast.Attribute) and self.expr.func.value.attr in self.context.sigs:
contract_name = self.expr.func.value.attr
var = self.context.globals[self.expr.func.value.attr]
contract_address = unwrap_location(LLLnode.from_list(var.pos, typ=var.typ, location='storage', pos=getpos(self.expr), annotation='self.' + self.expr.func.value.attr))
value, gas = self._get_external_contract_keywords()
return external_contract_call(self.expr, self.context, contract_name, contract_address, pos=getpos(self.expr), value=value, gas=gas)
elif isinstance(self.expr.func.value, ast.Attribute) and self.expr.func.value.attr in self.context.globals:
contract_name = self.context.globals[self.expr.func.value.attr].typ.unit
var = self.context.globals[self.expr.func.value.attr]
contract_address = unwrap_location(LLLnode.from_list(var.pos, typ=var.typ, location='storage', pos=getpos(self.expr), annotation='self.' + self.expr.func.value.attr))
value, gas = self._get_external_contract_keywords()
return external_contract_call(self.expr, self.context, contract_name, contract_address, pos=getpos(self.expr), value=value, gas=gas)
else:
raise StructureException("Unsupported operator: %r" % ast.dump(self.expr), self.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 call(self):
from .parser import (
pack_logging_data,
pack_logging_topics,
external_contract_call,
)
if isinstance(self.stmt.func, ast.Name):
if self.stmt.func.id in stmt_dispatch_table:
return stmt_dispatch_table[self.stmt.func.id](self.stmt,
self.context)
elif self.stmt.func.id in dispatch_table:
raise StructureException(
"Function {} can not be called without being used.".format(
self.stmt.func.id), self.stmt)
else:
raise StructureException(
"Unknown function: '{}'.".format(self.stmt.func.id),
self.stmt)
elif isinstance(self.stmt.func, ast.Attribute) and isinstance(
self.stmt.func.value,
ast.Name) and self.stmt.func.value.id == "self":
return self_call.make_call(self.stmt, self.context)
elif isinstance(self.stmt.func, ast.Attribute) and isinstance(
self.stmt.func.value, ast.Call):
contract_name = self.stmt.func.value.func.id
contract_address = Expr.parse_value_expr(
self.stmt.func.value.args[0], self.context)
return external_contract_call(self.stmt,
self.context,
contract_name,
contract_address,
pos=getpos(self.stmt))
elif isinstance(self.stmt.func.value, ast.Attribute
) and self.stmt.func.value.attr in self.context.sigs:
contract_name = self.stmt.func.value.attr
var = self.context.globals[self.stmt.func.value.attr]
contract_address = unwrap_location(
LLLnode.from_list(var.pos,
typ=var.typ,
location='storage',
pos=getpos(self.stmt),
annotation='self.' +
self.stmt.func.value.attr))
return external_contract_call(self.stmt,
self.context,
contract_name,
contract_address,
pos=getpos(self.stmt))
elif isinstance(
self.stmt.func.value, ast.Attribute
) and self.stmt.func.value.attr in self.context.globals:
contract_name = self.context.globals[
self.stmt.func.value.attr].typ.unit
var = self.context.globals[self.stmt.func.value.attr]
contract_address = unwrap_location(
LLLnode.from_list(var.pos,
typ=var.typ,
location='storage',
pos=getpos(self.stmt),
annotation='self.' +
self.stmt.func.value.attr))
return external_contract_call(self.stmt,
self.context,
contract_name,
contract_address,
pos=getpos(self.stmt))
elif isinstance(self.stmt.func,
ast.Attribute) and self.stmt.func.value.id == 'log':
if self.stmt.func.attr not in self.context.sigs['self']:
raise EventDeclarationException("Event not declared yet: %s" %
self.stmt.func.attr)
event = self.context.sigs['self'][self.stmt.func.attr]
if len(event.indexed_list) != len(self.stmt.args):
raise EventDeclarationException(
"%s received %s arguments but expected %s" %
(event.name, len(self.stmt.args), len(event.indexed_list)))
expected_topics, topics = [], []
expected_data, data = [], []
for pos, is_indexed in enumerate(event.indexed_list):
if is_indexed:
expected_topics.append(event.args[pos])
topics.append(self.stmt.args[pos])
else:
expected_data.append(event.args[pos])
data.append(self.stmt.args[pos])
topics = pack_logging_topics(event.event_id,
topics,
expected_topics,
self.context,
pos=getpos(self.stmt))
inargs, inargsize, inargsize_node, inarg_start = pack_logging_data(
expected_data, data, self.context, pos=getpos(self.stmt))
if inargsize_node is None:
sz = inargsize
else:
sz = ['mload', inargsize_node]
return LLLnode.from_list([
'seq', inargs,
LLLnode.from_list(
["log" + str(len(topics)), inarg_start, sz] + topics,
add_gas_estimate=inargsize * 10)
],
typ=None,
pos=getpos(self.stmt))
else:
raise StructureException(
"Unsupported operator: %r" % ast.dump(self.stmt), self.stmt)
def parse_Return(self):
if self.context.return_type is None:
if self.stmt.value:
return
return LLLnode.from_list(
make_return_stmt(self.stmt, self.context, 0, 0),
typ=None,
pos=getpos(self.stmt),
valency=0,
)
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 self.context.return_type != sub.typ and not sub.typ.is_literal:
return
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 SizeLimits.in_bounds(self.context.return_type.typ,
sub.value):
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,
)
return
# Returning a byte array
elif isinstance(sub.typ, ByteArrayLike):
if not sub.typ.eq_base(self.context.return_type):
return
if sub.typ.maxlen > self.context.return_type.maxlen:
return
# 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,
)
return
elif isinstance(sub.typ, ListType):
loop_memory_position = self.context.new_placeholder(
typ=BaseType("uint256"))
if sub.typ != self.context.return_type:
return
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 isinstance(retty, StructType) and retty.name == sub.typ.name:
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):
return
if len(self.context.return_type.members) != len(sub.typ.members):
return
# 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):
return
return gen_tuple_return(self.stmt, self.context, sub)
def make_external_call(stmt_expr, context):
from vyper.parser.expr import Expr
value, gas = get_external_interface_keywords(stmt_expr, context)
if isinstance(stmt_expr.func, vy_ast.Attribute) and isinstance(
stmt_expr.func.value, vy_ast.Call
):
contract_name = stmt_expr.func.value.func.id
contract_address = Expr.parse_value_expr(stmt_expr.func.value.args[0], context)
return external_call(
stmt_expr,
context,
contract_name,
contract_address,
pos=getpos(stmt_expr),
value=value,
gas=gas,
)
elif (
isinstance(stmt_expr.func.value, vy_ast.Attribute)
and stmt_expr.func.value.attr in context.sigs
): # noqa: E501
contract_name = stmt_expr.func.value.attr
var = context.globals[stmt_expr.func.value.attr]
contract_address = unwrap_location(
LLLnode.from_list(
var.pos,
typ=var.typ,
location="storage",
pos=getpos(stmt_expr),
annotation="self." + stmt_expr.func.value.attr,
)
)
return external_call(
stmt_expr,
context,
contract_name,
contract_address,
pos=getpos(stmt_expr),
value=value,
gas=gas,
)
elif (
isinstance(stmt_expr.func.value, vy_ast.Attribute)
and stmt_expr.func.value.attr in context.globals
and hasattr(context.globals[stmt_expr.func.value.attr].typ, "name")
):
contract_name = context.globals[stmt_expr.func.value.attr].typ.name
var = context.globals[stmt_expr.func.value.attr]
contract_address = unwrap_location(
LLLnode.from_list(
var.pos,
typ=var.typ,
location="storage",
pos=getpos(stmt_expr),
annotation="self." + stmt_expr.func.value.attr,
)
)
return external_call(
stmt_expr,
context,
contract_name,
contract_address,
pos=getpos(stmt_expr),
value=value,
gas=gas,
)
else:
raise StructureException("Unsupported operator.", stmt_expr)
def pack_args_by_32(
holder,
maxlen,
arg,
typ,
context,
placeholder,
dynamic_offset_counter=None,
datamem_start=None,
pos=None,
):
"""
Copy necessary variables to pre-allocated memory section.
:param holder: Complete holder for all args
:param maxlen: Total length in bytes of the full arg section (static + dynamic).
:param arg: Current arg to pack
:param context: Context of arg
:param placeholder: Static placeholder for static argument part.
:param dynamic_offset_counter: position counter stored in static args.
:param dynamic_placeholder: pointer to current position in memory to write dynamic values to.
:param datamem_start: position where the whole datemem section starts.
"""
if typ.size_in_bytes == 32:
if isinstance(arg, LLLnode):
value = unwrap_location(arg)
else:
value = Expr(arg, context).lll_node
value = unwrap_location(value)
holder.append(LLLnode.from_list(["mstore", placeholder, value], location="memory"))
elif isinstance(typ, ArrayValueAbstractType):
if isinstance(arg, LLLnode): # Is prealloacted variable.
source_lll = arg
else:
source_lll = Expr(arg, context).lll_node
# Set static offset, in arg slot.
holder.append(LLLnode.from_list(["mstore", placeholder, ["mload", dynamic_offset_counter]]))
# Get the beginning to write the ByteArray to.
# TODO refactor out the use of `ByteArrayLike` once old types are removed from parser
dest_placeholder = LLLnode.from_list(
["add", datamem_start, ["mload", dynamic_offset_counter]],
typ=ByteArrayLike(typ.length),
location="memory",
annotation="pack_args_by_32:dest_placeholder",
)
copier = make_byte_array_copier(dest_placeholder, source_lll, pos=pos)
holder.append(copier)
# Add zero padding.
holder.append(zero_pad(dest_placeholder))
# Increment offset counter.
increment_counter = LLLnode.from_list(
[
"mstore",
dynamic_offset_counter,
[
"add",
[
"add",
["mload", dynamic_offset_counter],
["ceil32", ["mload", dest_placeholder]],
],
32,
],
],
annotation="Increment dynamic offset counter",
)
holder.append(increment_counter)
elif isinstance(typ, ArrayDefinition):
if isinstance(arg, vy_ast.Call) and arg.func.get("id") == "empty":
# special case for `empty()` with a static-sized array
holder.append(mzero(placeholder, typ.size_in_bytes))
maxlen += typ.size_in_bytes - 32
return holder, maxlen
maxlen += (typ.length - 1) * 32
typ = typ.value_type
# NOTE: Below code could be refactored into iterators/getter functions for each type of
# repetitive loop. But seeing how each one is a unique for loop, and in which way
# the sub value makes the difference in each type of list clearer.
# List from storage
if isinstance(arg, vy_ast.Attribute) and arg.value.id == "self":
stor_list = context.globals[arg.attr]
size = stor_list.typ.count
mem_offset = 0
for i in range(0, size):
storage_offset = i
arg2 = LLLnode.from_list(
["sload", ["add", Expr(arg, context).lll_node, storage_offset]],
)
holder, maxlen = pack_args_by_32(
holder, maxlen, arg2, typ, context, placeholder + mem_offset, pos=pos,
)
mem_offset += typ.size_in_bytes
# List from variable.
elif isinstance(arg, vy_ast.Name):
size = context.vars[arg.id].size
pos = context.vars[arg.id].pos
mem_offset = 0
for _ in range(0, size):
arg2 = LLLnode.from_list(pos + mem_offset, location=context.vars[arg.id].location)
holder, maxlen = pack_args_by_32(
holder, maxlen, arg2, typ, context, placeholder + mem_offset, pos=pos,
)
mem_offset += typ.size_in_bytes
# List from list literal.
else:
mem_offset = 0
for arg2 in arg.elements:
holder, maxlen = pack_args_by_32(
holder, maxlen, arg2, typ, context, placeholder + mem_offset, pos=pos,
)
mem_offset += typ.size_in_bytes
return holder, maxlen
def call(self):
from .parser import (
pack_arguments,
pack_logging_data,
pack_logging_topics,
external_contract_call,
)
if isinstance(self.stmt.func,
ast.Name) and self.stmt.func.id in stmt_dispatch_table:
return stmt_dispatch_table[self.stmt.func.id](self.stmt,
self.context)
elif isinstance(self.stmt.func, ast.Attribute) and isinstance(
self.stmt.func.value,
ast.Name) and self.stmt.func.value.id == "self":
method_name = self.stmt.func.attr
if method_name not in self.context.sigs['self']:
raise VariableDeclarationException(
"Function not declared yet (reminder: functions cannot "
"call functions later in code than themselves): %s" %
self.stmt.func.attr)
sig = self.context.sigs['self'][method_name]
if self.context.is_constant and not sig.const:
raise ConstancyViolationException(
"May not call non-constant function '%s' within a constant function."
% (method_name))
add_gas = self.context.sigs['self'][method_name].gas
inargs, inargsize = pack_arguments(
sig,
[Expr(arg, self.context).lll_node for arg in self.stmt.args],
self.context,
pos=getpos(self.stmt))
return LLLnode.from_list([
'assert',
['call', ['gas'], ['address'], 0, inargs, inargsize, 0, 0]
],
typ=None,
pos=getpos(self.stmt),
add_gas_estimate=add_gas,
annotation='Internal Call: %s' %
method_name)
elif isinstance(self.stmt.func, ast.Attribute) and isinstance(
self.stmt.func.value, ast.Call):
contract_name = self.stmt.func.value.func.id
contract_address = Expr.parse_value_expr(
self.stmt.func.value.args[0], self.context)
return external_contract_call(self.stmt,
self.context,
contract_name,
contract_address,
True,
pos=getpos(self.stmt))
elif isinstance(self.stmt.func.value, ast.Attribute
) and self.stmt.func.value.attr in self.context.sigs:
contract_name = self.stmt.func.value.attr
var = self.context.globals[self.stmt.func.value.attr]
contract_address = unwrap_location(
LLLnode.from_list(var.pos,
typ=var.typ,
location='storage',
pos=getpos(self.stmt),
annotation='self.' +
self.stmt.func.value.attr))
return external_contract_call(self.stmt,
self.context,
contract_name,
contract_address,
True,
pos=getpos(self.stmt))
elif isinstance(
self.stmt.func.value, ast.Attribute
) and self.stmt.func.value.attr in self.context.globals:
contract_name = self.context.globals[
self.stmt.func.value.attr].typ.unit
var = self.context.globals[self.stmt.func.value.attr]
contract_address = unwrap_location(
LLLnode.from_list(var.pos,
typ=var.typ,
location='storage',
pos=getpos(self.stmt),
annotation='self.' +
self.stmt.func.value.attr))
return external_contract_call(self.stmt,
self.context,
contract_name,
contract_address,
var.modifiable,
pos=getpos(self.stmt))
elif isinstance(self.stmt.func,
ast.Attribute) and self.stmt.func.value.id == 'log':
if self.stmt.func.attr not in self.context.sigs['self']:
raise VariableDeclarationException(
"Event not declared yet: %s" % self.stmt.func.attr)
event = self.context.sigs['self'][self.stmt.func.attr]
if len(event.indexed_list) != len(self.stmt.args):
raise VariableDeclarationException(
"%s received %s arguments but expected %s" %
(event.name, len(self.stmt.args), len(event.indexed_list)))
expected_topics, topics = [], []
expected_data, data = [], []
for pos, is_indexed in enumerate(event.indexed_list):
if is_indexed:
expected_topics.append(event.args[pos])
topics.append(self.stmt.args[pos])
else:
expected_data.append(event.args[pos])
data.append(self.stmt.args[pos])
topics = pack_logging_topics(event.event_id,
topics,
expected_topics,
self.context,
pos=getpos(self.stmt))
inargs, inargsize, inargsize_node, inarg_start = pack_logging_data(
expected_data, data, self.context, pos=getpos(self.stmt))
if inargsize_node is None:
sz = inargsize
else:
sz = ['mload', inargsize_node]
return LLLnode.from_list([
'seq', inargs,
LLLnode.from_list(
["log" + str(len(topics)), inarg_start, sz] + topics,
add_gas_estimate=inargsize * 10)
],
typ=None,
pos=getpos(self.stmt))
else:
raise StructureException(
"Unsupported operator: %r" % ast.dump(self.stmt), self.stmt)
def pack_args_by_32(holder,
maxlen,
arg,
typ,
context,
placeholder,
dynamic_offset_counter=None,
datamem_start=None,
zero_pad_i=None,
pos=None):
"""
Copy necessary variables to pre-allocated memory section.
:param holder: Complete holder for all args
:param maxlen: Total length in bytes of the full arg section (static + dynamic).
:param arg: Current arg to pack
:param context: Context of arg
:param placeholder: Static placeholder for static argument part.
:param dynamic_offset_counter: position counter stored in static args.
:param dynamic_placeholder: pointer to current position in memory to write dynamic values to.
:param datamem_start: position where the whole datemem section starts.
"""
if isinstance(typ, BaseType):
if isinstance(arg, LLLnode):
value = unwrap_location(arg)
else:
value = Expr(arg, context).lll_node
value = base_type_conversion(value, value.typ, typ, pos)
holder.append(
LLLnode.from_list(['mstore', placeholder, value],
typ=typ,
location='memory'))
elif isinstance(typ, ByteArrayLike):
if isinstance(arg, LLLnode): # Is prealloacted variable.
source_lll = arg
else:
source_lll = Expr(arg, context).lll_node
# Set static offset, in arg slot.
holder.append(
LLLnode.from_list(
['mstore', placeholder, ['mload', dynamic_offset_counter]]))
# Get the biginning to write the ByteArray to.
dest_placeholder = LLLnode.from_list(
['add', datamem_start, ['mload', dynamic_offset_counter]],
typ=typ,
location='memory',
annotation="pack_args_by_32:dest_placeholder")
copier = make_byte_array_copier(dest_placeholder, source_lll, pos=pos)
holder.append(copier)
# Add zero padding.
new_maxlen = ceil32(source_lll.typ.maxlen)
holder.append([
'with',
'_ceil32_end',
['ceil32', ['mload', dest_placeholder]],
[
'seq',
[
'with',
'_bytearray_loc',
dest_placeholder,
[
'seq',
[
'repeat',
zero_pad_i,
['mload', '_bytearray_loc'],
new_maxlen,
[
'seq',
# stay within allocated bounds
[
'if',
[
'ge', ['mload', zero_pad_i],
'_ceil32_end'
], 'break'
],
[
'mstore8',
[
'add', ['add', '_bytearray_loc', 32],
['mload', zero_pad_i]
],
0,
],
]
],
]
],
]
])
# Increment offset counter.
increment_counter = LLLnode.from_list(
[
'mstore',
dynamic_offset_counter,
[
'add',
[
'add', ['mload', dynamic_offset_counter],
['ceil32', ['mload', dest_placeholder]]
],
32,
],
],
annotation='Increment dynamic offset counter')
holder.append(increment_counter)
elif isinstance(typ, ListType):
maxlen += (typ.count - 1) * 32
typ = typ.subtype
def check_list_type_match(provided): # Check list types match.
if provided != typ:
raise TypeMismatchException(
"Log list type '%s' does not match provided, expected '%s'"
% (provided, typ))
# NOTE: Below code could be refactored into iterators/getter functions for each type of
# repetitive loop. But seeing how each one is a unique for loop, and in which way
# the sub value makes the difference in each type of list clearer.
# List from storage
if isinstance(arg, ast.Attribute) and arg.value.id == 'self':
stor_list = context.globals[arg.attr]
check_list_type_match(stor_list.typ.subtype)
size = stor_list.typ.count
mem_offset = 0
for i in range(0, size):
storage_offset = i
arg2 = LLLnode.from_list(
[
'sload',
[
'add', ['sha3_32',
Expr(arg, context).lll_node],
storage_offset
]
],
typ=typ,
)
holder, maxlen = pack_args_by_32(
holder,
maxlen,
arg2,
typ,
context,
placeholder + mem_offset,
pos=pos,
)
mem_offset += get_size_of_type(typ) * 32
# List from variable.
elif isinstance(arg, ast.Name):
size = context.vars[arg.id].size
pos = context.vars[arg.id].pos
check_list_type_match(context.vars[arg.id].typ.subtype)
mem_offset = 0
for _ in range(0, size):
arg2 = LLLnode.from_list(
pos + mem_offset,
typ=typ,
location=context.vars[arg.id].location)
holder, maxlen = pack_args_by_32(
holder,
maxlen,
arg2,
typ,
context,
placeholder + mem_offset,
pos=pos,
)
mem_offset += get_size_of_type(typ) * 32
# List from list literal.
else:
mem_offset = 0
for arg2 in arg.elts:
holder, maxlen = pack_args_by_32(
holder,
maxlen,
arg2,
typ,
context,
placeholder + mem_offset,
pos=pos,
)
mem_offset += get_size_of_type(typ) * 32
return holder, maxlen
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))
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)
# Returning something already in memory
if sub.location == 'memory':
return LLLnode.from_list([
'with', '_loc', sub,
[
'seq', ['mstore', ['sub', '_loc', 32], 32],
[
'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 = [
'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],
# 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 concat(expr, context):
args = [Expr(arg, context).lll_node for arg in expr.args]
if len(args) < 2:
raise StructureException("Concat expects at least two arguments", expr)
prev_type = ''
for i, (expr_arg, arg) in enumerate(zip(expr.args, args)):
if not isinstance(arg.typ, ByteArrayLike) and not is_base_type(arg.typ, 'bytes32'):
raise TypeMismatchException("Concat expects string, bytes or bytes32 objects", expr_arg)
current_type = 'bytes' if isinstance(arg.typ, ByteArrayType) or is_base_type(arg.typ, 'bytes32') else 'string'
if prev_type and current_type != prev_type:
raise TypeMismatchException("Concat expects consistant use of string or byte types, user either bytes or string.", expr_arg)
prev_type = current_type
if current_type == 'string':
ReturnType = StringType
else:
ReturnType = ByteArrayType
# Maximum length of the output
total_maxlen = sum([arg.typ.maxlen if isinstance(arg.typ, ByteArrayType) else 32 for arg in args])
# Node representing the position of the output in memory
placeholder = context.new_placeholder(ReturnType(total_maxlen))
# Object representing the output
seq = []
# For each argument we are concatenating...
for arg in args:
# Start pasting into a position the starts at zero, and keeps
# incrementing as we concatenate arguments
placeholder_node = LLLnode.from_list(['add', placeholder, '_poz'], typ=ReturnType(total_maxlen), location='memory')
placeholder_node_plus_32 = LLLnode.from_list(['add', ['add', placeholder, '_poz'], 32], typ=ReturnType(total_maxlen), location='memory')
if isinstance(arg.typ, ReturnType):
# Ignore empty strings
if arg.typ.maxlen == 0:
continue
# Get the length of the current argument
if arg.location == "memory":
length = LLLnode.from_list(['mload', '_arg'], typ=BaseType('int128'))
argstart = LLLnode.from_list(['add', '_arg', 32], typ=arg.typ, location=arg.location)
elif arg.location == "storage":
length = LLLnode.from_list(['sload', ['sha3_32', '_arg']], typ=BaseType('int128'))
argstart = LLLnode.from_list(['add', ['sha3_32', '_arg'], 1], typ=arg.typ, location=arg.location)
# Make a copier to copy over data from that argument
seq.append(['with', '_arg', arg,
['seq',
make_byte_slice_copier(placeholder_node_plus_32,
argstart,
length,
arg.typ.maxlen, pos=getpos(expr)),
# Change the position to start at the correct
# place to paste the next value
['set', '_poz', ['add', '_poz', length]]]])
else:
seq.append(['seq',
['mstore', ['add', placeholder_node, 32], unwrap_location(arg)],
['set', '_poz', ['add', '_poz', 32]]])
# The position, after all arguments are processing, equals the total
# length. Paste this in to make the output a proper bytearray
seq.append(['mstore', placeholder, '_poz'])
# Memory location of the output
seq.append(placeholder)
return LLLnode.from_list(
['with', '_poz', 0, ['seq'] + seq], typ=ReturnType(total_maxlen), location='memory', pos=getpos(expr), annotation='concat'
)
def parse_value_expr(expr, context):
return unwrap_location(Expr(expr, context).lll_node)
def avo(arg, ind, pos):
return unwrap_location(add_variable_offset(arg, LLLnode.from_list(ind, 'int128'), pos=pos))
def call(self):
from vyper.parser.parser import (external_contract_call)
from vyper.functions import (
dispatch_table, )
if isinstance(self.expr.func, ast.Name):
function_name = self.expr.func.id
if function_name in dispatch_table:
return dispatch_table[function_name](self.expr, self.context)
else:
err_msg = "Not a top-level function: {}".format(function_name)
if function_name in [
x.split('(')[0]
for x, _ in self.context.sigs['self'].items()
]:
err_msg += ". Did you mean self.{}?".format(function_name)
raise StructureException(err_msg, self.expr)
elif isinstance(self.expr.func, ast.Attribute) and isinstance(
self.expr.func.value,
ast.Name) and self.expr.func.value.id == "self":
return self_call.make_call(self.expr, self.context)
elif isinstance(self.expr.func, ast.Attribute) and isinstance(
self.expr.func.value, ast.Call):
contract_name = self.expr.func.value.func.id
contract_address = Expr.parse_value_expr(
self.expr.func.value.args[0], self.context)
value, gas = self._get_external_contract_keywords()
return external_contract_call(self.expr,
self.context,
contract_name,
contract_address,
pos=getpos(self.expr),
value=value,
gas=gas)
elif isinstance(self.expr.func.value, ast.Attribute
) and self.expr.func.value.attr in self.context.sigs:
contract_name = self.expr.func.value.attr
var = self.context.globals[self.expr.func.value.attr]
contract_address = unwrap_location(
LLLnode.from_list(var.pos,
typ=var.typ,
location='storage',
pos=getpos(self.expr),
annotation='self.' +
self.expr.func.value.attr))
value, gas = self._get_external_contract_keywords()
return external_contract_call(self.expr,
self.context,
contract_name,
contract_address,
pos=getpos(self.expr),
value=value,
gas=gas)
elif isinstance(
self.expr.func.value, ast.Attribute
) and self.expr.func.value.attr in self.context.globals:
contract_name = self.context.globals[
self.expr.func.value.attr].typ.unit
var = self.context.globals[self.expr.func.value.attr]
contract_address = unwrap_location(
LLLnode.from_list(var.pos,
typ=var.typ,
location='storage',
pos=getpos(self.expr),
annotation='self.' +
self.expr.func.value.attr))
value, gas = self._get_external_contract_keywords()
return external_contract_call(self.expr,
self.context,
contract_name,
contract_address,
pos=getpos(self.expr),
value=value,
gas=gas)
else:
raise StructureException(
"Unsupported operator: %r" % ast.dump(self.expr), self.expr)
def raw_log(expr, args, kwargs, context):
if not isinstance(args[0], ast.List) or len(args[0].elts) > 4:
raise StructureException(
"Expecting a list of 0-4 topics as first argument", args[0])
topics = []
for elt in args[0].elts:
arg = Expr.parse_value_expr(elt, context)
if not is_base_type(arg.typ, 'bytes32'):
raise TypeMismatchException(
"Expecting a bytes32 argument as topic", elt)
topics.append(arg)
if args[1].typ == BaseType('bytes32'):
placeholder = context.new_placeholder(BaseType('bytes32'))
return LLLnode.from_list([
'seq', ['mstore', placeholder,
unwrap_location(args[1])],
[
"log" + str(len(topics)),
placeholder,
32,
] + topics
],
typ=None,
pos=getpos(expr))
if args[1].location == "memory":
return LLLnode.from_list([
"with", "_arr", args[1],
[
"log" + str(len(topics)),
["add", "_arr", 32],
["mload", "_arr"],
] + topics
],
typ=None,
pos=getpos(expr))
placeholder = context.new_placeholder(args[1].typ)
placeholder_node = LLLnode.from_list(placeholder,
typ=args[1].typ,
location='memory')
copier = make_byte_array_copier(
placeholder_node,
LLLnode.from_list('_sub', typ=args[1].typ, location=args[1].location),
pos=getpos(expr),
)
return LLLnode.from_list(
[
"with",
"_sub",
args[1],
[
"seq", copier,
[
"log" + str(len(topics)),
["add", placeholder_node, 32],
["mload", placeholder_node],
] + topics
],
],
typ=None,
pos=getpos(expr),
)