def process_arg(index, arg, expected_arg_typelist, function_name, context):
if isinstance(expected_arg_typelist, Optional):
expected_arg_typelist = expected_arg_typelist.typ
if not isinstance(expected_arg_typelist, tuple):
expected_arg_typelist = (expected_arg_typelist, )
vsub = None
for expected_arg in expected_arg_typelist:
if expected_arg == 'num_literal':
if isinstance(arg, ast.Num) and get_original_if_0x_prefixed(
arg, context) is None:
return arg.n
elif expected_arg == 'str_literal':
if isinstance(arg, ast.Str) and get_original_if_0x_prefixed(
arg, context) is None:
bytez = b''
for c in arg.s:
if ord(c) >= 256:
raise InvalidLiteralException(
"Cannot insert special character %r into byte array"
% c, arg)
bytez += bytes([ord(c)])
return bytez
elif expected_arg == 'name_literal':
if isinstance(arg, ast.Name):
return arg.id
elif expected_arg == '*':
return arg
elif expected_arg == 'bytes':
sub = Expr(arg, context).lll_node
if isinstance(sub.typ, ByteArrayType):
return sub
else:
# Does not work for unit-endowed types inside compound types, eg. timestamp[2]
parsed_expected_type = parse_type(
ast.parse(expected_arg).body[0].value, 'memory')
if isinstance(parsed_expected_type, BaseType):
vsub = vsub or Expr.parse_value_expr(arg, context)
if is_base_type(vsub.typ, expected_arg):
return vsub
else:
vsub = vsub or Expr(arg, context).lll_node
if vsub.typ == parsed_expected_type:
return Expr(arg, context).lll_node
if len(expected_arg_typelist) == 1:
raise TypeMismatchException(
"Expecting %s for argument %r of %s" %
(expected_arg, index, function_name), arg)
else:
raise TypeMismatchException(
"Expecting one of %r for argument %r of %s" %
(expected_arg_typelist, index, function_name), arg)
return arg.id
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)
for expr_arg, arg in zip(expr.args, args):
if not isinstance(arg.typ, ByteArrayType) and not is_base_type(arg.typ, 'bytes32') and not is_base_type(arg.typ, 'method_id'):
raise TypeMismatchException("Concat expects byte arrays or bytes32 objects", expr_arg)
# 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(ByteArrayType(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=ByteArrayType(total_maxlen), location='memory')
placeholder_node_plus_32 = LLLnode.from_list(['add', ['add', placeholder, '_poz'], 32], typ=ByteArrayType(total_maxlen), location='memory')
if isinstance(arg.typ, ByteArrayType):
# 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('num'))
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('num'))
argstart = LLLnode.from_list(['add', ['sha3_32', '_arg'], 1], typ=arg.typ, location=arg.location)
# Make a copier to copy over data from that argyument
seq.append(['with', '_arg', arg,
['seq',
make_byte_slice_copier(placeholder_node_plus_32,
argstart,
length,
arg.typ.maxlen),
# Change the position to start at the correct
# place to paste the next value
['set', '_poz', ['add', '_poz', length]]]])
elif isinstance(arg.typ, BaseType) and arg.typ.typ == "method_id":
seq.append(['seq',
['mstore', ['add', placeholder_node, 32], arg.value * 2**224],
['set', '_poz', ['add', '_poz', 4]]])
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=ByteArrayType(total_maxlen), location='memory', pos=getpos(expr), annotation='concat'
)
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].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))
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))
