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):
value = parse_expr(arg, context)
value = base_type_conversion(value, value.typ, typ, pos)
holder.append(LLLnode.from_list(['mstore', placeholder, value], typ=typ, location='memory'))
elif isinstance(typ, ByteArrayType):
bytez = b''
source_expr = Expr(arg, context)
if isinstance(arg, ast.Str):
if len(arg.s) > typ.maxlen:
raise TypeMismatchException("Data input bytes are to big: %r %r" % (len(arg.s), typ), pos)
for c in arg.s:
if ord(c) >= 256:
raise InvalidLiteralException("Cannot insert special character %r into byte array" % c, pos)
bytez += bytes([ord(c)])
holder.append(source_expr.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_expr.lll_node)
holder.append(copier)
# Add zero padding.
new_maxlen = ceil32(source_expr.lll_node.typ.maxlen)
holder.append(
['with', '_bytearray_loc', dest_placeholder,
['seq',
['repeat', zero_pad_i, ['mload', '_bytearray_loc'], new_maxlen,
['seq',
['if', ['ge', ['mload', zero_pad_i], new_maxlen], 'break'], # stay within allocated bounds
['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]]
)
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)
)
# 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
for offset in range(0, size):
arg2 = LLLnode.from_list(['sload', ['add', ['sha3_32', Expr(arg, context).lll_node], offset]],
typ=typ)
p_holder = context.new_placeholder(BaseType(32)) if offset > 0 else placeholder
holder, maxlen = pack_args_by_32(holder, maxlen, arg2, typ, context, p_holder, pos=pos)
# 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)
for i in range(0, size):
offset = 32 * i
arg2 = LLLnode.from_list(pos + offset, typ=typ, location='memory')
p_holder = context.new_placeholder(BaseType(32)) if i > 0 else placeholder
holder, maxlen = pack_args_by_32(holder, maxlen, arg2, typ, context, p_holder, pos=pos)
# is list literal.
else:
holder, maxlen = pack_args_by_32(holder, maxlen, arg.elts[0], typ, context, placeholder, pos=pos)
for j, arg2 in enumerate(arg.elts[1:]):
holder, maxlen = pack_args_by_32(holder, maxlen, arg2, typ, context, context.new_placeholder(BaseType(32)), pos=pos)
return holder, maxlen
def make_setter(left, right, location, pos, in_function_call=False):
# Basic types
if isinstance(left.typ, BaseType):
right = base_type_conversion(
right,
right.typ,
left.typ,
pos,
in_function_call=in_function_call,
)
if location == 'storage':
return LLLnode.from_list(['sstore', left, right], typ=None)
elif location == 'memory':
return LLLnode.from_list(['mstore', left, right], typ=None)
# Byte arrays
elif isinstance(left.typ, ByteArrayLike):
return make_byte_array_copier(left, right, pos)
# Can't copy mappings
elif isinstance(left.typ, MappingType):
raise TypeMismatchException(
"Cannot copy mappings; can only copy individual elements", pos)
# Arrays
elif isinstance(left.typ, ListType):
# Cannot do something like [a, b, c] = [1, 2, 3]
if left.value == "multi":
raise Exception("Target of set statement must be a single item")
if not isinstance(right.typ, (ListType, NullType)):
raise TypeMismatchException(
"Setter type mismatch: left side is array, right side is %r" %
right.typ, pos)
left_token = LLLnode.from_list('_L',
typ=left.typ,
location=left.location)
if left.location == "storage":
left = LLLnode.from_list(['sha3_32', left],
typ=left.typ,
location="storage_prehashed")
left_token.location = "storage_prehashed"
# Type checks
if not isinstance(right.typ, NullType):
if not isinstance(right.typ, ListType):
raise TypeMismatchException(
"Left side is array, right side is not", pos)
if left.typ.count != right.typ.count:
raise TypeMismatchException("Mismatched number of elements",
pos)
# If the right side is a literal
if right.value == "multi":
if len(right.args) != left.typ.count:
raise TypeMismatchException("Mismatched number of elements",
pos)
subs = []
for i in range(left.typ.count):
subs.append(
make_setter(add_variable_offset(
left_token,
LLLnode.from_list(i, typ='int128'),
pos=pos,
array_bounds_check=False,
),
right.args[i],
location,
pos=pos))
return LLLnode.from_list(['with', '_L', left, ['seq'] + subs],
typ=None)
# If the right side is a null
# CC 20190619 probably not needed as of #1106
elif isinstance(right.typ, NullType):
subs = []
for i in range(left.typ.count):
subs.append(
make_setter(add_variable_offset(
left_token,
LLLnode.from_list(i, typ='int128'),
pos=pos,
array_bounds_check=False,
),
LLLnode.from_list(None, typ=NullType()),
location,
pos=pos))
return LLLnode.from_list(['with', '_L', left, ['seq'] + subs],
typ=None)
# If the right side is a variable
else:
right_token = LLLnode.from_list('_R',
typ=right.typ,
location=right.location)
subs = []
for i in range(left.typ.count):
subs.append(
make_setter(add_variable_offset(
left_token,
LLLnode.from_list(i, typ='int128'),
pos=pos,
array_bounds_check=False,
),
add_variable_offset(
right_token,
LLLnode.from_list(i, typ='int128'),
pos=pos,
array_bounds_check=False,
),
location,
pos=pos))
return LLLnode.from_list(
['with', '_L', left, ['with', '_R', right, ['seq'] + subs]],
typ=None)
# Structs
elif isinstance(left.typ, (StructType, TupleType)):
if left.value == "multi" and isinstance(left.typ, StructType):
raise Exception("Target of set statement must be a single item")
if not isinstance(right.typ, NullType):
if not isinstance(right.typ, left.typ.__class__):
raise TypeMismatchException(
"Setter type mismatch: left side is %r, right side is %r" %
(
left.typ,
right.typ,
),
pos,
)
if isinstance(left.typ, StructType):
for k in right.args:
if k.value is None:
raise InvalidLiteralException(
'Setting struct value to None is not allowed, use a default value.',
pos,
)
for k in left.typ.members:
if k not in right.typ.members:
raise TypeMismatchException(
"Keys don't match for structs, missing %s" % k,
pos,
)
for k in right.typ.members:
if k not in left.typ.members:
raise TypeMismatchException(
"Keys don't match for structs, extra %s" % k,
pos,
)
if left.typ.name != right.typ.name:
raise TypeMismatchException(
"Expected %r, got %r" % (left.typ, right.typ), pos)
else:
if len(left.typ.members) != len(right.typ.members):
raise TypeMismatchException(
"Tuple lengths don't match, %d vs %d" % (
len(left.typ.members),
len(right.typ.members),
),
pos,
)
left_token = LLLnode.from_list('_L',
typ=left.typ,
location=left.location)
if left.location == "storage":
left = LLLnode.from_list(['sha3_32', left],
typ=left.typ,
location="storage_prehashed")
left_token.location = "storage_prehashed"
if isinstance(left.typ, StructType):
keyz = list(left.typ.members.keys())
else:
keyz = list(range(len(left.typ.members)))
# If the left side is a literal
if left.value == 'multi':
locations = [arg.location for arg in left.args]
else:
locations = [location for _ in keyz]
# If the right side is a literal
if right.value == "multi":
if len(right.args) != len(keyz):
raise TypeMismatchException("Mismatched number of elements",
pos)
subs = []
for i, (typ, loc) in enumerate(zip(keyz, locations)):
subs.append(
make_setter(
add_variable_offset(left_token, typ, pos=pos),
right.args[i],
loc,
pos=pos,
))
return LLLnode.from_list(['with', '_L', left, ['seq'] + subs],
typ=None)
# If the right side is a null
elif isinstance(right.typ, NullType):
subs = []
for typ, loc in zip(keyz, locations):
subs.append(
make_setter(
add_variable_offset(left_token, typ, pos=pos),
LLLnode.from_list(None, typ=NullType()),
loc,
pos=pos,
))
return LLLnode.from_list(['with', '_L', left, ['seq'] + subs],
typ=None)
# If tuple assign.
elif isinstance(left.typ, TupleType) and isinstance(
right.typ, TupleType):
subs = []
static_offset_counter = 0
zipped_components = zip(left.args, right.typ.members, locations)
for var_arg in left.args:
if var_arg.location == 'calldata':
raise ConstancyViolationException(
f"Cannot modify function argument: {var_arg.annotation}",
pos)
for left_arg, right_arg, loc in zipped_components:
if isinstance(right_arg, ByteArrayLike):
RType = ByteArrayType if isinstance(
right_arg, ByteArrayType) else StringType
offset = LLLnode.from_list([
'add', '_R',
['mload', ['add', '_R', static_offset_counter]]
],
typ=RType(right_arg.maxlen),
location='memory',
pos=pos)
static_offset_counter += 32
else:
offset = LLLnode.from_list(
['mload', ['add', '_R', static_offset_counter]],
typ=right_arg.typ,
pos=pos,
)
static_offset_counter += get_size_of_type(right_arg) * 32
subs.append(make_setter(left_arg, offset, loc, pos=pos))
return LLLnode.from_list(
['with', '_R', right, ['seq'] + subs],
typ=None,
annotation='Tuple assignment',
)
# If the right side is a variable
else:
subs = []
right_token = LLLnode.from_list('_R',
typ=right.typ,
location=right.location)
for typ, loc in zip(keyz, locations):
subs.append(
make_setter(add_variable_offset(left_token, typ, pos=pos),
add_variable_offset(right_token, typ, pos=pos),
loc,
pos=pos))
return LLLnode.from_list(
['with', '_L', left, ['with', '_R', right, ['seq'] + subs]],
typ=None,
)
else:
raise Exception("Invalid type for setters")
def compare(self):
left = Expr.parse_value_expr(self.expr.left, self.context)
right = Expr.parse_value_expr(self.expr.comparators[0], self.context)
if isinstance(right.typ, NullType):
raise InvalidLiteralException('Comparison to None is not allowed, compare against a default value.', self.expr)
if isinstance(left.typ, ByteArrayType) and isinstance(right.typ, ByteArrayType):
if left.typ.maxlen != right.typ.maxlen:
raise TypeMismatchException('Can only compare bytes of the same length', self.expr)
if left.typ.maxlen > 32 or right.typ.maxlen > 32:
raise ParserException('Can only compare bytes of length shorter than 32 bytes', self.expr)
elif isinstance(self.expr.ops[0], ast.In) and \
isinstance(right.typ, ListType):
if left.typ != right.typ.subtype:
raise TypeMismatchException("Can't use IN comparison with different types!", self.expr)
return self.build_in_comparator()
else:
if not are_units_compatible(left.typ, right.typ) and not are_units_compatible(right.typ, left.typ):
raise TypeMismatchException("Can't compare values with different units!", self.expr)
if len(self.expr.ops) != 1:
raise StructureException("Cannot have a comparison with more than two elements", self.expr)
if isinstance(self.expr.ops[0], ast.Gt):
op = 'sgt'
elif isinstance(self.expr.ops[0], ast.GtE):
op = 'sge'
elif isinstance(self.expr.ops[0], ast.LtE):
op = 'sle'
elif isinstance(self.expr.ops[0], ast.Lt):
op = 'slt'
elif isinstance(self.expr.ops[0], ast.Eq):
op = 'eq'
elif isinstance(self.expr.ops[0], ast.NotEq):
op = 'ne'
else:
raise Exception("Unsupported comparison operator")
# Compare (limited to 32) byte arrays.
if isinstance(left.typ, ByteArrayType) and isinstance(left.typ, ByteArrayType):
left = Expr(self.expr.left, self.context).lll_node
right = Expr(self.expr.comparators[0], self.context).lll_node
def load_bytearray(side):
if side.location == 'memory':
return ['mload', ['add', 32, side]]
elif side.location == 'storage':
return ['sload', ['add', 1, ['sha3_32', side]]]
return LLLnode.from_list(
[op, load_bytearray(left), load_bytearray(right)], typ='bool', pos=getpos(self.expr))
# Compare other types.
if not is_numeric_type(left.typ) or not is_numeric_type(right.typ):
if op not in ('eq', 'ne'):
raise TypeMismatchException("Invalid type for comparison op", self.expr)
left_type, right_type = left.typ.typ, right.typ.typ
# Special Case: comparison of a literal integer. If in valid range allow it to be compared.
if {left_type, right_type} == {'int128', 'uint256'} and {left.typ.is_literal, right.typ.is_literal} == {True, False}:
comparison_allowed = False
if left.typ.is_literal and SizeLimits.in_bounds(right_type, left.value):
comparison_allowed = True
elif right.typ.is_literal and SizeLimits.in_bounds(left_type, right.value):
comparison_allowed = True
op = self._signed_to_unsigned_comparision_op(op)
if comparison_allowed:
return LLLnode.from_list([op, left, right], typ='bool', pos=getpos(self.expr))
elif {left_type, right_type} == {'uint256', 'uint256'}:
op = self._signed_to_unsigned_comparision_op(op)
elif (left_type in ('decimal', 'int128') or right_type in ('decimal', 'int128')) and left_type != right_type:
raise TypeMismatchException(
'Implicit conversion from {} to {} disallowed, please convert.'.format(left_type, right_type),
self.expr
)
if left_type == right_type:
return LLLnode.from_list([op, left, right], typ='bool', pos=getpos(self.expr))
else:
raise TypeMismatchException("Unsupported types for comparison: %r %r" % (left_type, right_type), self.expr)
def assign(self):
# Assignment (e.g. x[4] = y)
if len(self.stmt.targets) != 1:
raise StructureException(
"Assignment statement must have one target", self.stmt)
with self.context.assignment_scope():
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_rlp_list_assign = (isinstance(
self.stmt.value, ast.Call)) and getattr(
self.stmt.value.func, 'id', '') == 'RLPList'
# Determine if it's an RLPList assignment.
if is_valid_rlp_list_assign:
pos = self.context.new_variable(self.stmt.targets[0].id,
sub.typ)
variable_loc = LLLnode.from_list(
pos,
typ=sub.typ,
location='memory',
pos=getpos(self.stmt),
annotation=self.stmt.targets[0].id,
)
o = make_setter(variable_loc,
sub,
'memory',
pos=getpos(self.stmt))
else:
# Error check when assigning to declared variable
if isinstance(self.stmt.targets[0], ast.Name):
# Do not allow assignment to undefined variables without annotation
if self.stmt.targets[0].id not in self.context.vars:
raise VariableDeclarationException(
"Variable type not defined", self.stmt)
# Check against implicit conversion
self._check_implicit_conversion(self.stmt.targets[0].id,
sub)
is_valid_tuple_assign = (isinstance(
self.stmt.targets[0], ast.Tuple)) and isinstance(
self.stmt.value, ast.Tuple)
# Do no allow tuple-to-tuple assignment
if is_valid_tuple_assign:
raise VariableDeclarationException(
"Tuple to tuple assignment not supported",
self.stmt,
)
# Checks to see if assignment is valid
target = self.get_target(self.stmt.targets[0])
if isinstance(target.typ, ContractType) and not isinstance(
sub.typ, ContractType):
raise TypeMismatchException(
'Contract assignment expects casted address: '
f'{target.typ.unit}(<address_var>)', self.stmt)
o = make_setter(target,
sub,
target.location,
pos=getpos(self.stmt))
o.pos = getpos(self.stmt)
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(
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:
# Iterator used to zero pad memory.
zero_pad_i = self.context.new_placeholder(BaseType('uint256'))
zero_padder = LLLnode.from_list(
[
'with',
'_ceil32_end',
['ceil32', ['mload', bytez_placeholder]],
[
'repeat',
zero_pad_i,
['mload', bytez_placeholder],
maxlen,
[
'seq',
# stay within allocated bounds
[
'if',
[
'gt', ['mload', zero_pad_i],
'_ceil32_end'
], 'break'
],
[
'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
# 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): # 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(
"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 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, 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 dict_fail(self):
warnings.warn(
"Anonymous structs have been removed in"
" favor of named structs, see VIP300", DeprecationWarning)
raise InvalidLiteralException(
"Invalid literal: %r" % ast.dump(self.expr), self.expr)
def parse_docblock(self):
if '"""' not in self.context.origcode.splitlines()[self.stmt.lineno -
1]:
raise InvalidLiteralException('Only valid """ docblocks allowed',
self.stmt)
return LLLnode.from_list('pass', typ=None, pos=getpos(self.stmt))
def _slice(expr, args, kwargs, context):
sub, start, length = args[0], kwargs['start'], kwargs['len']
if not are_units_compatible(start.typ, BaseType('int128')):
raise TypeMismatchException("Type for slice start index must be a unitless number", expr)
# Expression representing the length of the slice
if not are_units_compatible(length.typ, BaseType('int128')):
raise TypeMismatchException("Type for slice length must be a unitless number", expr)
if is_base_type(sub.typ, 'bytes32'):
if (start.typ.is_literal and length.typ.is_literal) and \
not (0 <= start.value + length.value <= 32):
raise InvalidLiteralException('Invalid start / length values needs to be between 0 and 32.', expr)
sub_typ_maxlen = 32
else:
sub_typ_maxlen = sub.typ.maxlen
# Node representing the position of the output in memory
np = context.new_placeholder(ByteArrayType(maxlen=sub_typ_maxlen + 32))
# Get returntype string or bytes
if isinstance(args[0].typ, ByteArrayType) or is_base_type(sub.typ, 'bytes32'):
ReturnType = ByteArrayType
else:
ReturnType = StringType
# Node representing the position of the output in memory
np = context.new_placeholder(ReturnType(maxlen=sub_typ_maxlen + 32))
placeholder_node = LLLnode.from_list(np, typ=sub.typ, location='memory')
placeholder_plus_32_node = LLLnode.from_list(np + 32, typ=sub.typ, location='memory')
# Copies over bytearray data
if sub.location == 'storage':
adj_sub = LLLnode.from_list(
['add', ['sha3_32', sub], ['add', ['div', '_start', 32], 1]], typ=sub.typ, location=sub.location
)
else:
adj_sub = LLLnode.from_list(
['add', sub, ['add', ['sub', '_start', ['mod', '_start', 32]], 32]], typ=sub.typ, location=sub.location
)
if is_base_type(sub.typ, 'bytes32'):
adj_sub = LLLnode.from_list(
sub.args[0], typ=sub.typ, location="memory"
)
copier = make_byte_slice_copier(placeholder_plus_32_node, adj_sub, ['add', '_length', 32], sub_typ_maxlen, pos=getpos(expr))
# New maximum length in the type of the result
newmaxlen = length.value if not len(length.args) else sub_typ_maxlen
if is_base_type(sub.typ, 'bytes32'):
maxlen = 32
else:
maxlen = ['mload', Expr(sub, context=context).lll_node] # Retrieve length of the bytes.
out = ['with', '_start', start,
['with', '_length', length,
['with', '_opos', ['add', placeholder_node, ['mod', '_start', 32]],
['seq',
['assert', ['le', ['add', '_start', '_length'], maxlen]],
copier,
['mstore', '_opos', '_length'],
'_opos']]]]
return LLLnode.from_list(out, typ=ReturnType(newmaxlen), location='memory', 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(
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 to_decimal(expr, args, kwargs, context):
in_arg = args[0]
input_type, _ = get_type(in_arg)
if input_type == 'bytes':
if in_arg.typ.maxlen > 32:
raise TypeMismatchException(
f"Cannot convert bytes array of max length {in_arg.typ.maxlen} to decimal",
expr,
)
num = byte_array_to_num(in_arg, expr, 'int128')
return LLLnode.from_list(
['mul', num, DECIMAL_DIVISOR],
typ=BaseType('decimal'),
pos=getpos(expr)
)
else:
_unit = in_arg.typ.unit
_positional = in_arg.typ.positional
if input_type == 'uint256':
if in_arg.typ.is_literal:
if not SizeLimits.in_bounds('int128', (in_arg.value * DECIMAL_DIVISOR)):
raise InvalidLiteralException(
f"Number out of range: {in_arg.value}",
expr,
)
else:
return LLLnode.from_list(
['mul', in_arg, DECIMAL_DIVISOR],
typ=BaseType('decimal', _unit, _positional),
pos=getpos(expr)
)
else:
return LLLnode.from_list(
[
'uclample',
['mul', in_arg, DECIMAL_DIVISOR],
['mload', MemoryPositions.MAXDECIMAL]
],
typ=BaseType('decimal', _unit, _positional),
pos=getpos(expr)
)
elif input_type == 'address':
return LLLnode.from_list(
[
'mul',
[
'signextend',
15,
[
'and',
in_arg,
(SizeLimits.ADDRSIZE - 1)
],
],
DECIMAL_DIVISOR
],
typ=BaseType('decimal', _unit, _positional),
pos=getpos(expr)
)
elif input_type == 'bytes32':
if in_arg.typ.is_literal:
if not SizeLimits.in_bounds('int128', (in_arg.value * DECIMAL_DIVISOR)):
raise InvalidLiteralException(
f"Number out of range: {in_arg.value}",
expr,
)
else:
return LLLnode.from_list(
['mul', in_arg, DECIMAL_DIVISOR],
typ=BaseType('decimal', _unit, _positional),
pos=getpos(expr)
)
else:
return LLLnode.from_list(
[
'clamp',
['mload', MemoryPositions.MINDECIMAL],
['mul', in_arg, DECIMAL_DIVISOR],
['mload', MemoryPositions.MAXDECIMAL],
],
typ=BaseType('decimal', _unit, _positional),
pos=getpos(expr)
)
elif input_type in ('int128', 'bool'):
return LLLnode.from_list(
['mul', in_arg, DECIMAL_DIVISOR],
typ=BaseType('decimal', _unit, _positional),
pos=getpos(expr)
)
else:
raise InvalidLiteralException(f"Invalid input for decimal: {in_arg}", expr)
def to_int128(expr, args, kwargs, context):
in_arg = args[0]
input_type, _ = get_type(in_arg)
_unit = in_arg.typ.unit if input_type in ('uint256', 'decimal') else None
if input_type == 'num_literal':
if isinstance(in_arg, int):
if not SizeLimits.in_bounds('int128', in_arg):
raise InvalidLiteralException(f"Number out of range: {in_arg}")
return LLLnode.from_list(
in_arg,
typ=BaseType('int128', _unit),
pos=getpos(expr)
)
elif isinstance(in_arg, float):
if not SizeLimits.in_bounds('int128', math.trunc(in_arg)):
raise InvalidLiteralException(f"Number out of range: {math.trunc(in_arg)}")
return LLLnode.from_list(
math.trunc(in_arg),
typ=BaseType('int128', _unit),
pos=getpos(expr)
)
else:
raise InvalidLiteralException(f"Unknown numeric literal type: {in_arg}")
elif input_type == 'bytes32':
if in_arg.typ.is_literal:
if not SizeLimits.in_bounds('int128', in_arg.value):
raise InvalidLiteralException(f"Number out of range: {in_arg.value}", expr)
else:
return LLLnode.from_list(
in_arg,
typ=BaseType('int128', _unit),
pos=getpos(expr)
)
else:
return LLLnode.from_list(
[
'clamp',
['mload', MemoryPositions.MINNUM],
in_arg,
['mload', MemoryPositions.MAXNUM],
],
typ=BaseType('int128', _unit),
pos=getpos(expr)
)
elif input_type == 'address':
return LLLnode.from_list(
[
'signextend',
15,
[
'and',
in_arg,
(SizeLimits.ADDRSIZE - 1)
],
],
typ=BaseType('int128', _unit),
pos=getpos(expr)
)
elif input_type in ('string', 'bytes'):
if in_arg.typ.maxlen > 32:
raise TypeMismatchException(
f"Cannot convert bytes array of max length {in_arg.typ.maxlen} to int128",
expr,
)
return byte_array_to_num(in_arg, expr, 'int128')
elif input_type == 'uint256':
if in_arg.typ.is_literal:
if not SizeLimits.in_bounds('int128', in_arg.value):
raise InvalidLiteralException(f"Number out of range: {in_arg.value}", expr)
else:
return LLLnode.from_list(
in_arg,
typ=BaseType('int128', _unit),
pos=getpos(expr)
)
else:
return LLLnode.from_list(
['uclample', in_arg, ['mload', MemoryPositions.MAXNUM]],
typ=BaseType('int128', _unit),
pos=getpos(expr)
)
elif input_type == 'decimal':
return LLLnode.from_list(
[
'clamp',
['mload', MemoryPositions.MINNUM],
['sdiv', in_arg, DECIMAL_DIVISOR],
['mload', MemoryPositions.MAXNUM],
],
typ=BaseType('int128', _unit),
pos=getpos(expr)
)
elif input_type == 'bool':
return LLLnode.from_list(
in_arg,
typ=BaseType('int128', _unit),
pos=getpos(expr)
)
else:
raise InvalidLiteralException(f"Invalid input for int128: {in_arg}", expr)
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(f"Number out of range: {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(f"Number out of range: {math.trunc(in_arg)}")
return LLLnode.from_list(
math.trunc(in_arg),
typ=BaseType('uint256', _unit),
pos=getpos(expr)
)
else:
raise InvalidLiteralException(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', _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(
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 InvalidLiteralException(f"Invalid input for uint256: {in_arg}", expr)
def make_setter(left, right, location, pos, in_function_call=False):
# Basic types
if isinstance(left.typ, BaseType):
right = base_type_conversion(
right,
right.typ,
left.typ,
pos,
in_function_call=in_function_call,
)
# TODO this overlaps a type check in parser.stmt.Stmt._check_valid_assign
# and should be examined during a refactor (@iamdefinitelyahuman)
if 'int' in left.typ.typ and isinstance(right.value, int):
if not SizeLimits.in_bounds(left.typ.typ, right.value):
raise InvalidLiteralException(
f"Number out of range for {left.typ}: {right.value}", pos)
if location == 'storage':
return LLLnode.from_list(['sstore', left, right], typ=None)
elif location == 'memory':
return LLLnode.from_list(['mstore', left, right], typ=None)
# Byte arrays
elif isinstance(left.typ, ByteArrayLike):
return make_byte_array_copier(left, right, pos)
# Can't copy mappings
elif isinstance(left.typ, MappingType):
raise TypeMismatchException(
"Cannot copy mappings; can only copy individual elements", pos)
# Arrays
elif isinstance(left.typ, ListType):
# Cannot do something like [a, b, c] = [1, 2, 3]
if left.value == "multi":
raise Exception("Target of set statement must be a single item")
if not isinstance(right.typ, (ListType, NullType)):
raise TypeMismatchException(
f"Setter type mismatch: left side is array, right side is {right.typ}",
pos)
left_token = LLLnode.from_list('_L',
typ=left.typ,
location=left.location)
if left.location == "storage":
left = LLLnode.from_list(['sha3_32', left],
typ=left.typ,
location="storage_prehashed")
left_token.location = "storage_prehashed"
# Type checks
if not isinstance(right.typ, NullType):
if not isinstance(right.typ, ListType):
raise TypeMismatchException(
"Left side is array, right side is not", pos)
if left.typ.count != right.typ.count:
raise TypeMismatchException("Mismatched number of elements",
pos)
# If the right side is a literal
if right.value == "multi":
if len(right.args) != left.typ.count:
raise TypeMismatchException("Mismatched number of elements",
pos)
subs = []
for i in range(left.typ.count):
subs.append(
make_setter(add_variable_offset(
left_token,
LLLnode.from_list(i, typ='int128'),
pos=pos,
array_bounds_check=False,
),
right.args[i],
location,
pos=pos))
return LLLnode.from_list(['with', '_L', left, ['seq'] + subs],
typ=None)
# If the right side is a null
# CC 20190619 probably not needed as of #1106
elif isinstance(right.typ, NullType):
subs = []
for i in range(left.typ.count):
subs.append(
make_setter(add_variable_offset(
left_token,
LLLnode.from_list(i, typ='int128'),
pos=pos,
array_bounds_check=False,
),
LLLnode.from_list(None, typ=NullType()),
location,
pos=pos))
return LLLnode.from_list(['with', '_L', left, ['seq'] + subs],
typ=None)
# If the right side is a variable
else:
right_token = LLLnode.from_list('_R',
typ=right.typ,
location=right.location)
subs = []
for i in range(left.typ.count):
subs.append(
make_setter(add_variable_offset(
left_token,
LLLnode.from_list(i, typ='int128'),
pos=pos,
array_bounds_check=False,
),
add_variable_offset(
right_token,
LLLnode.from_list(i, typ='int128'),
pos=pos,
array_bounds_check=False,
),
location,
pos=pos))
return LLLnode.from_list(
['with', '_L', left, ['with', '_R', right, ['seq'] + subs]],
typ=None)
# Structs
elif isinstance(left.typ, TupleLike):
if left.value == "multi" and isinstance(left.typ, StructType):
raise Exception("Target of set statement must be a single item")
if not isinstance(right.typ, NullType):
if not isinstance(right.typ, left.typ.__class__):
raise TypeMismatchException(
f"Setter type mismatch: left side is {left.typ}, right side is {right.typ}",
pos,
)
if isinstance(left.typ, StructType):
for k in right.args:
if k.value is None:
raise InvalidLiteralException(
'Setting struct value to None is not allowed, use a default value.',
pos,
)
for k in left.typ.members:
if k not in right.typ.members:
raise TypeMismatchException(
f"Keys don't match for structs, missing {k}",
pos,
)
for k in right.typ.members:
if k not in left.typ.members:
raise TypeMismatchException(
f"Keys don't match for structs, extra {k}",
pos,
)
if left.typ.name != right.typ.name:
raise TypeMismatchException(
f"Expected {left.typ}, got {right.typ}", pos)
else:
if len(left.typ.members) != len(right.typ.members):
raise TypeMismatchException(
"Tuple lengths don't match, "
f"{len(left.typ.members)} vs {len(right.typ.members)}",
pos,
)
left_token = LLLnode.from_list('_L',
typ=left.typ,
location=left.location)
if left.location == "storage":
left = LLLnode.from_list(['sha3_32', left],
typ=left.typ,
location="storage_prehashed")
left_token.location = "storage_prehashed"
keyz = left.typ.tuple_keys()
# If the left side is a literal
if left.value == 'multi':
locations = [arg.location for arg in left.args]
else:
locations = [location for _ in keyz]
# If the right side is a literal
if right.value == "multi":
if len(right.args) != len(keyz):
raise TypeMismatchException("Mismatched number of elements",
pos)
# get the RHS arguments into a dict because
# they are not guaranteed to be in the same order
# the LHS keys.
right_args = dict(zip(right.typ.tuple_keys(), right.args))
subs = []
for (key, loc) in zip(keyz, locations):
subs.append(
make_setter(
add_variable_offset(left_token, key, pos=pos),
right_args[key],
loc,
pos=pos,
))
return LLLnode.from_list(['with', '_L', left, ['seq'] + subs],
typ=None)
# If the right side is a null
elif isinstance(right.typ, NullType):
subs = []
for typ, loc in zip(keyz, locations):
subs.append(
make_setter(
add_variable_offset(left_token, typ, pos=pos),
LLLnode.from_list(None, typ=NullType()),
loc,
pos=pos,
))
return LLLnode.from_list(['with', '_L', left, ['seq'] + subs],
typ=None)
# If tuple assign.
elif isinstance(left.typ, TupleType) and isinstance(
right.typ, TupleType):
subs = []
static_offset_counter = 0
zipped_components = zip(left.args, right.typ.members, locations)
for var_arg in left.args:
if var_arg.location == 'calldata':
raise ConstancyViolationException(
f"Cannot modify function argument: {var_arg.annotation}",
pos)
for left_arg, right_arg, loc in zipped_components:
if isinstance(right_arg, ByteArrayLike):
RType = ByteArrayType if isinstance(
right_arg, ByteArrayType) else StringType
offset = LLLnode.from_list([
'add', '_R',
['mload', ['add', '_R', static_offset_counter]]
],
typ=RType(right_arg.maxlen),
location='memory',
pos=pos)
static_offset_counter += 32
else:
offset = LLLnode.from_list(
['mload', ['add', '_R', static_offset_counter]],
typ=right_arg.typ,
pos=pos,
)
static_offset_counter += get_size_of_type(right_arg) * 32
subs.append(make_setter(left_arg, offset, loc, pos=pos))
return LLLnode.from_list(
['with', '_R', right, ['seq'] + subs],
typ=None,
annotation='Tuple assignment',
)
# If the right side is a variable
else:
subs = []
right_token = LLLnode.from_list('_R',
typ=right.typ,
location=right.location)
for typ, loc in zip(keyz, locations):
subs.append(
make_setter(add_variable_offset(left_token, typ, pos=pos),
add_variable_offset(right_token, typ, pos=pos),
loc,
pos=pos))
return LLLnode.from_list(
['with', '_L', left, ['with', '_R', right, ['seq'] + subs]],
typ=None,
)
else:
raise Exception("Invalid type for setters")
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 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)
return LLLnode.from_list(
['seq', ['mstore', 0, sub], ['return', 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], ['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)
# 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':
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)
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 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 context.constants.is_constant_of_base_type(
arg, ('uint256', 'int128')):
return context.constants.get_constant(arg.id, None).value
if isinstance(arg, ast.Num) and get_original_if_0_prefixed(
arg, context) is None:
return arg.n
elif expected_arg == 'str_literal':
if isinstance(arg, ast.Str) and get_original_if_0_prefixed(
arg, context) is None:
bytez = b''
for c in arg.s:
if ord(c) >= 256:
raise InvalidLiteralException(
f"Cannot insert special character {c} into byte array",
arg,
)
bytez += bytes([ord(c)])
return bytez
elif expected_arg == 'bytes_literal':
if isinstance(arg, ast.Bytes):
return arg.s
elif expected_arg == 'name_literal':
if isinstance(arg, ast.Name):
return arg.id
elif isinstance(arg, ast.Subscript) and arg.value.id == 'bytes':
return f'bytes[{arg.slice.value.n}]'
elif expected_arg == '*':
return arg
elif expected_arg == 'bytes':
sub = Expr(arg, context).lll_node
if isinstance(sub.typ, ByteArrayType):
return sub
elif expected_arg == 'string':
sub = Expr(arg, context).lll_node
if isinstance(sub.typ, StringType):
return sub
else:
# Does not work for unit-endowed types inside compound types, e.g. timestamp[2]
parsed_expected_type = context.parse_type(
parse_to_ast(expected_arg)[0].value,
'memory',
)
if isinstance(parsed_expected_type, BaseType):
vsub = vsub or Expr.parse_value_expr(arg, context)
is_valid_integer = ((expected_arg in ('int128', 'uint256')
and isinstance(vsub.typ, BaseType))
and (vsub.typ.typ in ('int128', 'uint256')
and vsub.typ.is_literal)
and (SizeLimits.in_bounds(
expected_arg, vsub.value)))
if is_base_type(vsub.typ, expected_arg):
return vsub
elif is_valid_integer:
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(
f"Expecting {expected_arg} for argument {index} of {function_name}",
arg)
else:
raise TypeMismatchException(
f"Expecting one of {expected_arg_typelist} for argument {index} of {function_name}",
arg)
def number(self):
orignum = get_original_if_0_prefixed(self.expr, self.context)
if orignum is None and isinstance(self.expr.n, int):
# Literal (mostly likely) becomes int128
if SizeLimits.in_bounds('int128', self.expr.n) or self.expr.n < 0:
return LLLnode.from_list(self.expr.n,
typ=BaseType('int128',
unit=None,
is_literal=True),
pos=getpos(self.expr))
# Literal is large enough (mostly likely) becomes uint256.
else:
return LLLnode.from_list(self.expr.n,
typ=BaseType('uint256',
unit=None,
is_literal=True),
pos=getpos(self.expr))
elif isinstance(self.expr.n, float):
numstring, num, den = get_number_as_fraction(
self.expr, self.context)
# if not SizeLimits.in_bounds('decimal', num // den):
# if not SizeLimits.MINDECIMAL * den <= num <= SizeLimits.MAXDECIMAL * den:
if not (SizeLimits.MINNUM * den < num < SizeLimits.MAXNUM * den):
raise InvalidLiteralException(
"Number out of range: " + numstring, self.expr)
if DECIMAL_DIVISOR % den:
raise InvalidLiteralException(
"Too many decimal places: " + numstring, self.expr)
return LLLnode.from_list(num * DECIMAL_DIVISOR // den,
typ=BaseType('decimal', unit=None),
pos=getpos(self.expr))
# Binary literal.
elif orignum[:2] == '0b':
str_val = orignum[2:]
total_bits = len(orignum[2:])
total_bits = total_bits if total_bits % 8 == 0 else total_bits + 8 - (
total_bits % 8) # ceil8 to get byte length.
if len(
orignum[2:]
) != total_bits: # Support only full formed bit definitions.
raise InvalidLiteralException(
"Bit notation requires a multiple of 8 bits / 1 byte. {} bit(s) are missing."
.format(total_bits - len(orignum[2:])), self.expr)
byte_len = int(total_bits / 8)
placeholder = self.context.new_placeholder(ByteArrayType(byte_len))
seq = []
seq.append(['mstore', placeholder, byte_len])
for i in range(0, total_bits, 256):
section = str_val[i:i + 256]
int_val = int(section, 2) << (256 - len(section)
) # bytes are right padded.
seq.append(['mstore', ['add', placeholder, i + 32], int_val])
return LLLnode.from_list(
['seq'] + seq + [placeholder],
typ=ByteArrayType(byte_len),
location='memory',
pos=getpos(self.expr),
annotation='Create ByteArray (Binary literal): %s' % str_val)
elif len(orignum) == 42:
if checksum_encode(orignum) != orignum:
raise InvalidLiteralException(
"""Address checksum mismatch. If you are sure this is the
right address, the correct checksummed form is: %s""" %
checksum_encode(orignum), self.expr)
return LLLnode.from_list(self.expr.n,
typ=BaseType('address', is_literal=True),
pos=getpos(self.expr))
elif len(orignum) == 66:
return LLLnode.from_list(self.expr.n,
typ=BaseType('bytes32', is_literal=True),
pos=getpos(self.expr))
else:
raise InvalidLiteralException(
"Cannot read 0x value with length %d. Expecting 42 (address incl 0x) or 66 (bytes32 incl 0x)"
% len(orignum), 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(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 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))
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 number(self):
orignum = get_original_if_0_prefixed(self.expr, self.context)
if orignum is None and isinstance(self.expr.n, int):
# Literal becomes int128
if (SizeLimits.MINNUM <= self.expr.n <= SizeLimits.MAXNUM):
return LLLnode.from_list(self.expr.n,
typ=BaseType('int128',
None,
is_literal=True),
pos=getpos(self.expr))
# Literal is large enough, becomes uint256.
elif 0 <= self.expr.n <= SizeLimits.MAX_UINT256:
return LLLnode.from_list(self.expr.n,
typ=BaseType('uint256',
None,
is_literal=True),
pos=getpos(self.expr))
else:
raise InvalidLiteralException(
"Number out of range: " + str(self.expr.n), self.expr)
elif isinstance(self.expr.n, float):
numstring, num, den = get_number_as_fraction(
self.expr, self.context)
if not (SizeLimits.MINNUM * den < num < SizeLimits.MAXNUM * den):
raise InvalidLiteralException(
"Number out of range: " + numstring, self.expr)
if DECIMAL_DIVISOR % den:
raise InvalidLiteralException(
"Too many decimal places: " + numstring, self.expr)
return LLLnode.from_list(num * DECIMAL_DIVISOR // den,
typ=BaseType('decimal', None),
pos=getpos(self.expr))
# Binary literal.
elif orignum[:2] == '0b':
str_val = orignum[2:]
total_bits = len(orignum[2:])
total_bits = total_bits if total_bits % 8 == 0 else total_bits + 8 - (
total_bits % 8) # ceil8 to get byte length.
if total_bits != len(orignum[2:]): # add necessary zero padding.
pad_len = total_bits - len(orignum[2:])
str_val = pad_len * '0' + str_val
byte_len = int(total_bits / 8)
placeholder = self.context.new_placeholder(ByteArrayType(byte_len))
seq = []
seq.append(['mstore', placeholder, byte_len])
for i in range(0, total_bits, 256):
section = str_val[i:i + 256]
int_val = int(section, 2) << (256 - len(section)
) # bytes are right padded.
seq.append(['mstore', ['add', placeholder, i + 32], int_val])
return LLLnode.from_list(
['seq'] + seq + [placeholder],
typ=ByteArrayType(byte_len),
location='memory',
pos=getpos(self.expr),
annotation='Create ByteArray (Binary literal): %s' % str_val)
elif len(orignum) == 42:
if checksum_encode(orignum) != orignum:
raise InvalidLiteralException(
"Address checksum mismatch. If you are sure this is the "
"right address, the correct checksummed form is: " +
checksum_encode(orignum), self.expr)
return LLLnode.from_list(self.expr.n,
typ=BaseType('address', is_literal=True),
pos=getpos(self.expr))
elif len(orignum) == 66:
return LLLnode.from_list(self.expr.n,
typ=BaseType('bytes32', is_literal=True),
pos=getpos(self.expr))
else:
raise InvalidLiteralException(
"Cannot read 0x value with length %d. Expecting 42 (address incl 0x) or 66 (bytes32 incl 0x)"
% len(orignum), self.expr)
