Merge pull request #410 from LefterisJP/add_extra_args_to_solc

Add extra args to solc

Author: konradkonrad

ethereum/_solidity.py

@@ -3,6 +3,7 @@
 import re
 import subprocess
 import warnings
+import shlex
 
 import yaml
 
@@ -45,16 +46,22 @@ def get_solidity():
     return solc_wrapper
 
 
-def solc_arguments(libraries=None, combined='bin,abi', optimize=True):
+def solc_arguments(libraries=None, combined='bin,abi', optimize=True, extra_args=None):
     """ Build the arguments to call the solc binary. """
     args = [
         '--combined-json', combined,
-        '--add-std',
+        '--add-std'
     ]
 
     if optimize:
         args.append('--optimize')
 
+    if extra_args:
+        try:
+            args.extend(shlex.split(extra_args))
+        except:  # if not a parseable string then treat it as a list
+            args.extend(extra_args)
+
     if libraries is not None and len(libraries):
         addresses = [
             '{name}:{address}'.format(name=name, address=address.decode('utf8'))
@@ -70,6 +77,10 @@ def solc_arguments(libraries=None, combined='bin,abi', optimize=True):
 
 def solc_parse_output(compiler_output):
     """ Parses the compiler output. """
+    # At the moment some solc output like --hashes or -- gas will not output
+    # json at all so if used with those arguments the logic here will break.
+    # Perhaps solidity will slowly switch to a json only output and this comment
+    # can eventually go away and we will not need to add more logic here at all.
     result = yaml.safe_load(compiler_output)['contracts']
 
     if 'bin' in tuple(result.values())[0]:
@@ -98,7 +109,7 @@ def solc_parse_output(compiler_output):
 def compiler_version():
     """ Return the version of the installed solc. """
     version_info = subprocess.check_output(['solc', '--version'])
-    match = re.search('^Version: ([0-9a-z.-]+)/', version_info, re.MULTILINE)
+    match = re.search(b'^Version: ([0-9a-z.-]+)/', version_info, re.MULTILINE)
 
     if match:
         return match.group(1)
@@ -190,7 +201,7 @@ def solidity_resolve_address(hex_code, library_symbol, library_address):
         raise ValueError('Address should not contain the 0x prefix')
 
     try:
-        _ = decode_hex(library_address)
+        decode_hex(library_address)
     except TypeError:
         raise ValueError('library_address contains invalid characters, it must be hex encoded.')
 
@@ -226,7 +237,7 @@ def solidity_unresolved_symbols(hex_code):
     return set(re.findall(r"_.{39}", hex_code))
 
 
-def compile_file(filepath, libraries=None, combined='bin,abi', optimize=True):
+def compile_file(filepath, libraries=None, combined='bin,abi', optimize=True, extra_args=None):
     """ Return the compile contract code.
 
     Args:
@@ -241,7 +252,7 @@ def compile_file(filepath, libraries=None, combined='bin,abi', optimize=True):
 
     workdir, filename = os.path.split(filepath)
 
-    args = solc_arguments(libraries=libraries, combined=combined, optimize=optimize)
+    args = solc_arguments(libraries=libraries, combined=combined, optimize=optimize, extra_args=extra_args)
     args.insert(0, get_compiler_path())
     args.append(filename)
 
@@ -250,18 +261,19 @@ def compile_file(filepath, libraries=None, combined='bin,abi', optimize=True):
     return solc_parse_output(output)
 
 
-def compile_contract(filepath, contract_name, libraries=None, combined='bin,abi', optimize=True):
+def compile_contract(filepath, contract_name, libraries=None, combined='bin,abi', optimize=True, extra_args=None):
     all_contracts = compile_file(
         filepath,
         libraries=libraries,
         combined=combined,
         optimize=optimize,
+        extra_args=extra_args
     )
 
     return all_contracts[contract_name]
 
 
-def compile_last_contract(filepath, libraries=None, combined='bin,abi', optimize=True):
+def compile_last_contract(filepath, libraries=None, combined='bin,abi', optimize=True, extra_args=None):
     with open(filepath) as handler:
         all_names = solidity_names(handler.read())
 
@@ -278,11 +290,12 @@ def compile_last_contract(filepath, libraries=None, combined='bin,abi', optimize
         libraries=libraries,
         combined=combined,
         optimize=optimize,
+        extra_args=extra_args
     )
 
 
-def compile_code(sourcecode, libraries=None, combined='bin,abi', optimize=True):
-    args = solc_arguments(libraries=libraries, combined=combined, optimize=optimize)
+def compile_code(sourcecode, libraries=None, combined='bin,abi', optimize=True, extra_args=None):
+    args = solc_arguments(libraries=libraries, combined=combined, optimize=optimize, extra_args=extra_args)
     args.insert(0, get_compiler_path())
 
     process = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -302,17 +315,17 @@ class Solc(object):
     compiler_version = staticmethod(compiler_version)
 
     @staticmethod
-    def _code_or_path(sourcecode, path, contract_name, libraries, combined):
+    def _code_or_path(sourcecode, path, contract_name, libraries, combined, extra_args):
         warnings.warn('solc_wrapper is deprecated, please use the functions compile_file or compile_code')
 
         if sourcecode and path:
             raise ValueError('sourcecode and path are mutually exclusive.')
 
         if path and contract_name:
-            return compile_contract(path, contract_name, libraries=libraries, combined=combined)
+            return compile_contract(path, contract_name, libraries=libraries, combined=combined, extra_args=extra_args)
 
         if path:
-            return compile_last_contract(path, libraries=libraries, combined=combined)
+            return compile_last_contract(path, libraries=libraries, combined=combined, extra_args=extra_args)
 
         all_names = solidity_names(sourcecode)
         all_contract_names = [
@@ -321,41 +334,44 @@ def _code_or_path(sourcecode, path, contract_name, libraries, combined):
         ]
         last_contract = all_contract_names[-1]
 
-        result = compile_code(sourcecode, libraries=libraries, combined=combined)
+        result = compile_code(sourcecode, libraries=libraries, combined=combined, extra_args=extra_args)
         return result[last_contract]
 
     @classmethod
-    def compile(cls, code, path=None, libraries=None, contract_name=''):
+    def compile(cls, code, path=None, libraries=None, contract_name='', extra_args=None):
         """ Return the binary of last contract in code. """
-        result = cls._code_or_path(code, path, contract_name, libraries, 'bin')
+        result = cls._code_or_path(code, path, contract_name, libraries, 'bin', extra_args)
         return result['bin']
 
     @classmethod
-    def mk_full_signature(cls, code, path=None, libraries=None, contract_name=''):
+    def mk_full_signature(cls, code, path=None, libraries=None, contract_name='', extra_args=None):
         "returns signature of last contract in code"
 
-        result = cls._code_or_path(code, path, contract_name, libraries, 'abi')
+        result = cls._code_or_path(code, path, contract_name, libraries, 'abi', extra_args)
         return result['abi']
 
     @classmethod
-    def combined(cls, code, path=None):
+    def combined(cls, code, path=None, extra_args=None):
         """ Compile combined-json with abi,bin,devdoc,userdoc.
 
         @param code: literal solidity code as a string.
-        @param path: absolute path to solidity-file. Note: code & path are exclusive!
+        @param path: absolute path to solidity-file. Note: code & path are
+                     mutually exclusive!
+        @param extra_args: Either a space separated string or a list of extra
+                           arguments to be passed to the solidity compiler.
         """
 
         if code and path:
             raise ValueError('sourcecode and path are mutually exclusive.')
 
         if path:
-            contracts = compile_file(path)
+            contracts = compile_file(path, extra_args=extra_args)
 
             with open(path) as handler:
                 code = handler.read()
 
         elif code:
-            contracts = compile_code(code)
+            contracts = compile_code(code, extra_args=extra_args)
 
         else:
             raise ValueError('either code or path needs to be supplied.')
@@ -366,7 +382,7 @@ def combined(cls, code, path=None):
         return sorted_contracts
 
     @classmethod
-    def compile_rich(cls, code, path=None):
+    def compile_rich(cls, code, path=None, extra_args=None):
         """full format as returned by jsonrpc"""
 
         return {
@@ -383,7 +399,7 @@ def compile_rich(cls, code, path=None):
                 },
             }
             for contract_name, contract
-            in cls.combined(code, path=path)
+            in cls.combined(code, path=path, extra_args=extra_args)
         }
 
 

ethereum/tests/test_solidity.py

@@ -14,6 +14,9 @@
 CONTRACTS_DIR = path.join(path.dirname(__file__), 'contracts')
 
 
+def bytecode_is_generated(cinfo, cname):
+    return 'code' in cinfo[cname] and len(cinfo[cname]['code']) > 10
+
 @pytest.mark.skipif(not SOLIDITY_AVAILABLE, reason='solc compiler not available')
 def test_library_from_file():
     state = tester.state()
@@ -188,7 +191,6 @@ def test_constructor():
     assert contract.getValue() == 2
 
 
-@pytest.mark.xfail(reason='bytecode in test seems to be wrong')
 @pytest.mark.skipif(not SOLIDITY_AVAILABLE, reason='solc compiler not available')
 def test_solidity_compile_rich():
     compile_rich_contract = """
@@ -211,22 +213,9 @@ def test_solidity_compile_rich():
         'language', 'languageVersion', 'abiDefinition', 'source',
         'compilerVersion', 'developerDoc', 'userDoc'
     }
-    assert contract_info['contract_add']['code'] == (
-        '0x606060405260ad8060116000396000f30060606040526000357c0100000000000000'
-        '00000000000000000000000000000000000000000090048063651ae239146041578063'
-        'cb02919f14606657603f565b005b6050600480359060200150608b565b604051808281'
-        '5260200191505060405180910390f35b6075600480359060200150609c565b60405180'
-        '82815260200191505060405180910390f35b60006007820190506097565b919050565b'
-        '6000602a8201905060a8565b91905056'
-    )
-    assert contract_info['contract_sub']['code'] == (
-        '0x606060405260ad8060116000396000f30060606040526000357c0100000000000000'
-        '0000000000000000000000000000000000000000009004806361752024146041578063'
-        '7aaef1a014606657603f565b005b6050600480359060200150608b565b604051808281'
-        '5260200191505060405180910390f35b6075600480359060200150609c565b60405180'
-        '82815260200191505060405180910390f35b60006007820390506097565b919050565b'
-        '6000602a8203905060a8565b91905056'
-    )
+    assert bytecode_is_generated(contract_info, 'contract_add')
+    assert bytecode_is_generated(contract_info, 'contract_sub')
+
     assert {
         defn['name']
         for defn
@@ -252,22 +241,31 @@ def test_abi_contract():
     }
     """
 
-    two_contracts = one_contract + """
-    contract baz {
-        function echo(address a) returns (address b) {
-            b = a;
-            return b;
-        }
-        function eight() returns (int256 y) {
-            y = 8;
-        }
-    }
-    """
-
     state = tester.state()
     contract = state.abi_contract(one_contract, language='solidity')
 
     # pylint: disable=no-member
     assert contract.seven() == 7
     assert contract.mul2(2) == 4
     assert contract.mul2(-2) == -4
+
+@pytest.mark.skipif(not SOLIDITY_AVAILABLE, reason='solc compiler not available')
+def test_extra_args():
+    src = """
+    contract foo {
+        function add7(uint a) returns(uint d) { return a + 7; }
+        function add42(uint a) returns(uint d) { return a + 42; }
+    }
+    """
+
+    contract_info = get_solidity().compile_rich(
+        src,
+        extra_args="--optimize-runs 100"
+    )
+    assert bytecode_is_generated(contract_info, 'foo')
+
+    contract_info = get_solidity().compile_rich(
+        src,
+        extra_args=["--optimize-runs", "100"]
+    )
+    assert bytecode_is_generated(contract_info, 'foo')