Added byte array literal support

vub · vub · commit 4a5866cf3e33 · 2017-02-06T01:01:41.000-05:00
diff --git a/README.md b/README.md
@@ -37,17 +37,22 @@ Note that not all programs that satisfy the following are valid; for example, th
         OR <var>.<membername>
         OR <var>[<expr>]
     varname = <str>
-    expr = <int>
+    expr = <literal>
         OR <expr> <binop> <expr>
         OR <expr> <boolop> <expr>
         OR <expr> <compareop> <expr>
         OR not <expr>
         OR <var>
         OR <expr>.balance
-        OR <literal>
+        OR <system_var>
         OR <basetype>(<expr>) (only some type conversions allowed)
         OR floor(<expr>)
-    literal = (block.timestamp, block.coinbase, block.number, block.difficulty, tx.origin, tx.gasprice, msg.gas, self)
+    literal = <integer>
+        OR <fixed point number>
+        OR <address, in the form 0x12cd2f...3fe>
+        OR <bytes32, in the form 0x414db52e5....2a7d>
+        OR <bytes, in the form "cow">
+    system_var = (block.timestamp, block.coinbase, block.number, block.difficulty, tx.origin, tx.gasprice, msg.gas, self)
     basetype = (num, decimal, bool, address, bytes32)
     unit = <baseunit>
         OR <baseunit> * <positive integer>
@@ -89,6 +94,8 @@ Arithmetic is overflow-checked, meaning that if a number is out of range then an
 
 In all three cases, it's possible to statically determine the maximum runtime of a loop. Jumping out of a loop before it ends can be done with either `break` or `return`.
 
+Regarding byte array literals, unicode strings like "这个傻老外不懂中文" or "Я очень умный" are illegal, though those that manage to use values that are in the 0...255 range according to UTF-8, like "¡très bien!", are fine.
+
 Code examples can be found in the `test_parser.py` file.
 
 ### Planned future features
@@ -98,7 +105,6 @@ Code examples can be found in the `test_parser.py` file.
 * A mini-language for handling num256 and signed256 values and directly / unsafely using opcodes; will be useful for high-performance code segments
 * Support for sha3, sha256, ecrecover, etc
 * Smart optimizations, including compile-time computation of arithmetic and clamps, intelligently computing realistic variable ranges, etc
-* Basic byte array slicing, splicing and byte access
 
 ### Code example
 
diff --git a/tests/test_invalids.py b/tests/test_invalids.py
@@ -1076,3 +1076,39 @@ def cat(i1: bytes <= 10, i2: bytes <= 30) -> bytes <= 40:
 def cat(i1: bytes <= 10, i2: bytes <= 30) -> bytes <= 40:
     return concat(i1, 5)
 """, TypeMismatchException)
+
+must_succeed("""
+def foo() -> bytes <= 10:
+    return "badminton"
+""")
+
+must_fail("""
+def foo() -> bytes <= 10:
+    return "badmintonzz"
+""", TypeMismatchException)
+
+must_succeed("""
+def foo() -> bytes <= 10:
+    return slice("badmintonzzz", start=1, len=10)
+""")
+
+must_fail("""
+def foo() -> bytes <= 10:
+    x = '0x1234567890123456789012345678901234567890'
+    x = 0x1234567890123456789012345678901234567890
+""", TypeMismatchException)
+
+must_fail("""
+def foo():
+    x = "these bytes are nо gооd because the o's are from the Russian alphabet"
+""", InvalidLiteralException)
+
+must_fail("""
+def foo():
+    x = "这个傻老外不懂中文"
+""", InvalidLiteralException)
+
+must_succeed("""
+def foo():
+    x = "¡très bien!"
+""")
diff --git a/tests/test_parser.py b/tests/test_parser.py
@@ -8,6 +8,7 @@
 s = t.state()
 t.languages['viper'] = compiler_plugin.Compiler() 
 
+
 null_code = """
 def foo():
     pass
@@ -1087,3 +1088,50 @@ def foo(inp: bytes <= 50) -> bytes <= 1000:
 c = s.abi_contract(test_concat2, language='viper')
 assert c.foo("horse" * 9 + "viper") == (b"horse" * 9 + b"viper") * 10
 print('Passed second concat test')
+
+string_literal_code = """
+def foo() -> bytes <= 5:
+    return "horse"
+
+def bar() -> bytes <= 10:
+    return concat("b", "a", "d", "m", "i", "", "nton")
+
+def baz() -> bytes <= 40:
+    return concat("0123456789012345678901234567890", "12")
+
+def baz2() -> bytes <= 40:
+    return concat("01234567890123456789012345678901", "12")
+
+def baz3() -> bytes <= 40:
+    return concat("0123456789012345678901234567890", "1")
+
+def baz4() -> bytes <= 100:
+    return concat("01234567890123456789012345678901234567890123456789",
+                  "01234567890123456789012345678901234567890123456789")
+"""
+
+c = s.abi_contract(string_literal_code, language='viper')
+assert c.foo() == b"horse"
+assert c.bar() == b"badminton"
+assert c.baz() == b"012345678901234567890123456789012"
+assert c.baz2() == b"0123456789012345678901234567890112"
+assert c.baz3() == b"01234567890123456789012345678901"
+assert c.baz4() == b"0123456789" * 10
+
+print("String literal test passed")
+
+for i in range(95, 96, 97):
+    kode = """
+def foo(s: num, L: num) -> bytes <= 100:
+        x = 27
+        r = slice("%s", start=s, len=L)
+        y = 37
+        if x * y == 999:
+            return r
+    """ % ("c" * i)
+    c = s.abi_contract(kode, language='viper')
+    for e in range(63, 64, 65):
+        for _s in range(31, 32, 33):
+            assert c.foo(_s, e - _s) == b"c" * (e - _s), (i, _s, e - _s, c.foo(_s, e - _s))
+
+print("String literal splicing fuzz-test passed")
diff --git a/viper/parser.py b/viper/parser.py
@@ -36,7 +36,10 @@ def fourbytes_to_int(inp):
 def hex_to_int(inp):
     if inp[:2] == '0x':
         inp = inp[2:]
-    bytez = binascii.unhexlify(inp)
+    return bytes_to_int(binascii.unhexlify(inp))
+
+# Converts bytes to an integer
+def bytes_to_int(bytez):
     o = 0
     for b in bytez:
         o = o * 256 + b
@@ -301,7 +304,7 @@ def mk_full_signature(code):
 def parse_tree_to_lll(code, origcode):
     _defs, _globals = get_defs_and_globals(code)
     if len(set([_def.name for _def in _defs])) < len(_defs):
-        raise VariableDeclarationException("Duplicate function name!")
+        raise VariableDeclarationException("Duplicate function name: %s" % [x for x in _defs if _defs.count(x) > 1][0])
     # Initialization function
     initfunc = [_def for _def in _defs if is_initializer(_def)]
     # Regular functions
@@ -319,7 +322,6 @@ def parse_tree_to_lll(code, origcode):
 
 # Parses a function declaration
 def parse_func(code, _globals, origcode, _vars=None):
-    assert isinstance(origcode, str)
     name, args, output_type, const, sig, method_id = get_func_details(code)
     for arg in args:
         if arg[0] in _globals:
@@ -426,7 +428,17 @@ def parse_expr(expr, context):
             raise InvalidLiteralException("Cannot read 0x value with length %d. Expecting 40 (address) or 64 (bytes32)" % L)
     # Byte array literals
     elif isinstance(expr, ast.Str):
-        raise Exception("Not yet implemented")
+        bytez = b''
+        for c in expr.s:
+            if ord(c) >= 256:
+                raise InvalidLiteralException("Cannot insert special character %r into byte array" % c)
+            bytez += bytes([ord(c)])
+        placeholder = context.new_placeholder(ByteArrayType(len(bytez)))
+        seq = []
+        seq.append(['mstore', placeholder, len(bytez)])
+        for i in range(0, len(bytez), 32):
+            seq.append(['mstore', ['add', placeholder, i + 32], bytes_to_int((bytez + b'\x00' * 31)[i: i + 32])])
+        return LLLnode.from_list(['seq'] + seq + [placeholder], typ=ByteArrayType(len(bytez)), location='memory')
     # True, False, None constants
     elif isinstance(expr, ast.NameConstant):
         if expr.value == True:
