{

if (_options.compiler.estimateGas)

return true;

if (!_options.output.dir.empty())

return false;

return

_options.compiler.outputs.abi ||

_options.compiler.outputs.asm_ ||

_options.compiler.outputs.asmJson ||

_options.compiler.outputs.binary ||

_options.compiler.outputs.binaryRuntime ||

_options.compiler.outputs.metadata ||

_options.compiler.outputs.natspecUser ||

_options.compiler.outputs.natspecDev ||

_options.compiler.outputs.opcodes ||

_options.compiler.outputs.signatureHashes ||

_options.compiler.outputs.storageLayout;

{

return

(!_options.formatting.coloredOutput.has_value() && isatty(STDERR_FILENO)) ||

(_options.formatting.coloredOutput.has_value() && _options.formatting.coloredOutput.value());

{

solAssert(m_assemblyStack);

solAssert(

CompilerInputModes.count(m_options.input.mode) == 1 ||

m_options.input.mode == frontend::InputMode::EVMAssemblerJSON

);

if (!m_options.compiler.outputs.asm_ && !m_options.compiler.outputs.asmJson)

return;

std::string assembly;

if (m_options.compiler.outputs.asmJson)

assembly = util::jsonPrint(removeNullMembers(m_assemblyStack->assemblyJSON(_contract)), m_options.formatting.json);

else

assembly = m_assemblyStack->assemblyString(_contract, m_fileReader.sourceUnits());

if (!m_options.output.dir.empty())

createFile(

m_compiler->filesystemFriendlyName(_contract) +

(m_options.compiler.outputs.asmJson ? "_evm.json" : ".evm"),

assembly

);

else

sout() << "EVM assembly:" << std::endl << assembly << std::endl;

{

solAssert(m_assemblyStack);

solAssert(

CompilerInputModes.count(m_options.input.mode) == 1 ||

m_options.input.mode == frontend::InputMode::EVMAssemblerJSON

);

std::string binary;

std::string binaryRuntime;

if (m_options.compiler.outputs.binary)

binary = objectWithLinkRefsHex(m_assemblyStack->object(_contract));

if (m_options.compiler.outputs.binaryRuntime)

binaryRuntime = objectWithLinkRefsHex(m_assemblyStack->runtimeObject(_contract));

if (m_options.compiler.outputs.binary)

{

if (!m_options.output.dir.empty())

createFile(m_assemblyStack->filesystemFriendlyName(_contract) + ".bin", binary);

else

{

sout() << "Binary:" << std::endl;

sout() << binary << std::endl;

}

}

if (m_options.compiler.outputs.binaryRuntime)

{

if (!m_options.output.dir.empty())

createFile(m_assemblyStack->filesystemFriendlyName(_contract) + ".bin-runtime", binaryRuntime);

else

{

sout() << "Binary of the runtime part:" << std::endl;

sout() << binaryRuntime << std::endl;

}

}

{

solAssert(m_assemblyStack);

solAssert(

CompilerInputModes.count(m_options.input.mode) == 1 ||

m_options.input.mode == frontend::InputMode::EVMAssemblerJSON

);

std::string opcodes{evmasm::disassemble(m_assemblyStack->object(_contract).bytecode, m_options.output.evmVersion)};

if (!m_options.output.dir.empty())

createFile(m_assemblyStack->filesystemFriendlyName(_contract) + ".opcode", opcodes);

else

{

sout() << "Opcodes:" << std::endl;

sout() << std::uppercase << opcodes;

sout() << std::endl;

}

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

if (!m_options.compiler.outputs.ir)

return;

if (!m_options.output.dir.empty())

createFile(m_compiler->filesystemFriendlyName(_contractName) + ".yul", m_compiler->yulIR(_contractName));

else

{

sout() << "IR:" << std::endl;

sout() << m_compiler->yulIR(_contractName) << std::endl;

}

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

if (!m_options.compiler.outputs.irAstJson)

return;

if (!m_options.output.dir.empty())

createFile(

m_compiler->filesystemFriendlyName(_contractName) + "_yul_ast.json",

util::jsonPrint(

m_compiler->yulIRAst(_contractName),

m_options.formatting.json

)

);

else

{

sout() << "IR AST:" << std::endl;

sout() << util::jsonPrint(

m_compiler->yulIRAst(_contractName),

m_options.formatting.json

) << std::endl;

}

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

if (!m_options.compiler.outputs.irOptimized)

return;

if (!m_options.output.dir.empty())

createFile(

m_compiler->filesystemFriendlyName(_contractName) + "_opt.yul",

m_compiler->yulIROptimized(_contractName)

);

else

{

sout() << "Optimized IR:" << std::endl;

sout() << m_compiler->yulIROptimized(_contractName) << std::endl;

}

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

if (!m_options.compiler.outputs.irOptimizedAstJson)

return;

if (!m_options.output.dir.empty())

createFile(

m_compiler->filesystemFriendlyName(_contractName) + "_opt_yul_ast.json",

util::jsonPrint(

m_compiler->yulIROptimizedAst(_contractName),

m_options.formatting.json

)

);

else

{

sout() << "Optimized IR AST:" << std::endl;

sout() << util::jsonPrint(

m_compiler->yulIROptimizedAst(_contractName),

m_options.formatting.json

) << std::endl;

}

{

solAssert(

CompilerInputModes.count(m_options.input.mode) == 1 ||

m_options.input.mode == frontend::InputMode::EVMAssemblerJSON

);

if (m_options.compiler.outputs.opcodes)

handleOpcode(_contract);

if (m_options.compiler.outputs.binary || m_options.compiler.outputs.binaryRuntime)

handleBinary(_contract);

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

if (!m_options.compiler.outputs.signatureHashes)

return;

Json::Value interfaceSymbols = m_compiler->interfaceSymbols(_contract);

std::string out = "Function signatures:\n";

for (auto const& name: interfaceSymbols["methods"].getMemberNames())

out += interfaceSymbols["methods"][name].asString() + ": " + name + "\n";

if (interfaceSymbols.isMember("errors"))

{

out += "\nError signatures:\n";

for (auto const& name: interfaceSymbols["errors"].getMemberNames())

out += interfaceSymbols["errors"][name].asString() + ": " + name + "\n";

}

if (interfaceSymbols.isMember("events"))

{

out += "\nEvent signatures:\n";

for (auto const& name: interfaceSymbols["events"].getMemberNames())

out += interfaceSymbols["events"][name].asString() + ": " + name + "\n";

}

if (!m_options.output.dir.empty())

createFile(m_compiler->filesystemFriendlyName(_contract) + ".signatures", out);

else

sout() << out;

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

if (!m_options.compiler.outputs.metadata)

return;

std::string data = m_compiler->metadata(_contract);

if (!m_options.output.dir.empty())

createFile(m_compiler->filesystemFriendlyName(_contract) + "_meta.json", data);

else

sout() << "Metadata:" << std::endl << data << std::endl;

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

if (!m_options.compiler.outputs.abi)

return;

std::string data = jsonPrint(removeNullMembers(m_compiler->contractABI(_contract)), m_options.formatting.json);

if (!m_options.output.dir.empty())

createFile(m_compiler->filesystemFriendlyName(_contract) + ".abi", data);

else

sout() << "Contract JSON ABI" << std::endl << data << std::endl;

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

if (!m_options.compiler.outputs.storageLayout)

return;

std::string data = jsonPrint(removeNullMembers(m_compiler->storageLayout(_contract)), m_options.formatting.json);

if (!m_options.output.dir.empty())

createFile(m_compiler->filesystemFriendlyName(_contract) + "_storage.json", data);

else

sout() << "Contract Storage Layout:" << std::endl << data << std::endl;

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

bool enabled = false;

std::string suffix;

std::string title;

if (_natspecDev)

{

enabled = m_options.compiler.outputs.natspecDev;

suffix = ".docdev";

title = "Developer Documentation";

}

else

{

enabled = m_options.compiler.outputs.natspecUser;

suffix = ".docuser";

title = "User Documentation";

}

if (enabled)

{

std::string output = jsonPrint(

removeNullMembers(

_natspecDev ?

m_compiler->natspecDev(_contract) :

m_compiler->natspecUser(_contract)

),

m_options.formatting.json

);

if (!m_options.output.dir.empty())

createFile(m_compiler->filesystemFriendlyName(_contract) + suffix, output);

else

{

sout() << title << std::endl;

sout() << output << std::endl;

}

}

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

Json::Value estimates = m_compiler->gasEstimates(_contract);

sout() << "Gas estimation:" << std::endl;

if (estimates["creation"].isObject())

{

Json::Value creation = estimates["creation"];

sout() << "construction:" << std::endl;

sout() << " " << creation["executionCost"].asString();

sout() << " + " << creation["codeDepositCost"].asString();

sout() << " = " << creation["totalCost"].asString() << std::endl;

}

if (estimates["external"].isObject())

{

Json::Value externalFunctions = estimates["external"];

sout() << "external:" << std::endl;

for (auto const& name: externalFunctions.getMemberNames())

{

if (name.empty())

sout() << " fallback:\t";

else

sout() << " " << name << ":\t";

sout() << externalFunctions[name].asString() << std::endl;

}

}

if (estimates["internal"].isObject())

{

Json::Value internalFunctions = estimates["internal"];

sout() << "internal:" << std::endl;

for (auto const& name: internalFunctions.getMemberNames())

{

sout() << " " << name << ":\t";

sout() << internalFunctions[name].asString() << std::endl;

}

}

{

solAssert(!m_standardJsonInput.has_value());

if (m_options.input.noImportCallback)

m_universalCallback.resetImportCallback();

static std::set<frontend::InputMode> const noInputFiles{

frontend::InputMode::Help,

frontend::InputMode::License,

frontend::InputMode::Version

};

if (noInputFiles.count(m_options.input.mode) == 1)

return;

m_fileReader.setBasePath(m_options.input.basePath);

if (m_fileReader.basePath() != "")

{

if (!boost::filesystem::exists(m_fileReader.basePath()))

solThrow(CommandLineValidationError, "Base path does not exist: \"" + m_fileReader.basePath().string() + '"');

if (!boost::filesystem::is_directory(m_fileReader.basePath()))

solThrow(CommandLineValidationError, "Base path is not a directory: \"" + m_fileReader.basePath().string() + '"');

}

for (boost::filesystem::path const& includePath: m_options.input.includePaths)

m_fileReader.addIncludePath(includePath);

for (boost::filesystem::path const& allowedDirectory: m_options.input.allowedDirectories)

m_fileReader.allowDirectory(allowedDirectory);

std::map<std::string, std::set<boost::filesystem::path>> collisions =

m_fileReader.detectSourceUnitNameCollisions(m_options.input.paths);

if (!collisions.empty())

{

auto pathToQuotedString = [](boost::filesystem::path const& _path){ return "\"" + _path.string() + "\""; };

std::string message =

"Source unit name collision detected. "

"The specified values of base path and/or include paths would result in multiple "

"input files being assigned the same source unit name:\n";

for (auto const& [sourceUnitName, normalizedInputPaths]: collisions)

{

message += sourceUnitName + " matches: ";

message += util::joinHumanReadable(normalizedInputPaths | ranges::views::transform(pathToQuotedString)) + "\n";

}

solThrow(CommandLineValidationError, message);

}

for (boost::filesystem::path const& infile: m_options.input.paths)

{

if (!boost::filesystem::exists(infile))

{

if (!m_options.input.ignoreMissingFiles)

solThrow(CommandLineValidationError, '"' + infile.string() + "\" is not found.");

else

report(Error::Severity::Info, fmt::format("\"{}\" is not found. Skipping.", infile.string()));

continue;

}

if (!boost::filesystem::is_regular_file(infile))

{

if (!m_options.input.ignoreMissingFiles)

solThrow(CommandLineValidationError, '"' + infile.string() + "\" is not a valid file.");

else

report(Error::Severity::Info, fmt::format("\"{}\" is not a valid file. Skipping.", infile.string()));

continue;

}

// NOTE: we ignore the FileNotFound exception as we manually check above

std::string fileContent = readFileAsString(infile);

if (m_options.input.mode == InputMode::StandardJson)

{

solAssert(!m_standardJsonInput.has_value());

m_standardJsonInput = std::move(fileContent);

}

else

{

m_fileReader.addOrUpdateFile(infile, std::move(fileContent));

m_fileReader.allowDirectory(boost::filesystem::canonical(infile).remove_filename());

}

}

if (m_options.input.addStdin)

{

if (m_options.input.mode == InputMode::StandardJson)

{

solAssert(!m_standardJsonInput.has_value());

m_standardJsonInput = readUntilEnd(m_sin);

}

else

m_fileReader.setStdin(readUntilEnd(m_sin));

}

if (

m_options.input.mode != InputMode::LanguageServer &&

m_fileReader.sourceUnits().empty() &&

!m_standardJsonInput.has_value()

)

solThrow(CommandLineValidationError, "All specified input files either do not exist or are not regular files.");

{

solAssert(m_options.input.mode == InputMode::CompilerWithASTImport);

std::map<std::string, Json::Value> sourceJsons;

std::map<std::string, std::string> tmpSources;

for (SourceCode const& sourceCode: m_fileReader.sourceUnits() | ranges::views::values)

{

Json::Value ast;

astAssert(jsonParseStrict(sourceCode, ast), "Input file could not be parsed to JSON");

astAssert(ast.isMember("sources"), "Invalid Format for import-JSON: Must have 'sources'-object");

for (auto& src: ast["sources"].getMemberNames())

{

std::string astKey = ast["sources"][src].isMember("ast") ? "ast" : "AST";

astAssert(ast["sources"][src].isMember(astKey), "astkey is not member");

astAssert(ast["sources"][src][astKey]["nodeType"].asString() == "SourceUnit", "Top-level node should be a 'SourceUnit'");

astAssert(sourceJsons.count(src) == 0, "All sources must have unique names");

sourceJsons.emplace(src, std::move(ast["sources"][src][astKey]));

tmpSources[src] = util::jsonCompactPrint(ast);

}

}

m_fileReader.setSourceUnits(tmpSources);

return sourceJsons;

{

namespace fs = boost::filesystem;

solAssert(!m_options.output.dir.empty());

// NOTE: create_directories() raises an exception if the path consists solely of '.' or '..'

// (or equivalent such as './././.'). Paths like 'a/b/.' and 'a/b/..' are fine though.

// The simplest workaround is to use an absolute path.

fs::create_directories(fs::absolute(m_options.output.dir));

std::string pathName = (m_options.output.dir / _fileName).string();

if (fs::exists(pathName) && !m_options.output.overwriteFiles)

solThrow(CommandLineOutputError, "Refusing to overwrite existing file \"" + pathName + "\" (use --overwrite to force).");

std::ofstream outFile(pathName);

outFile << _data;

if (!outFile)

solThrow(CommandLineOutputError, "Could not write to file \"" + pathName + "\".");

{

try

{

if (!parseArguments(_argc, _argv))

return false;

readInputFiles();

processInput();

return true;

}

catch (CommandLineError const& _exception)

{

m_hasOutput = true;

// There might be no message in the exception itself if the error output is bulky and has

// already been printed to stderr (this happens e.g. for compiler errors).

if (_exception.what() != ""s)

report(Error::Severity::Error, _exception.what());

return false;

}

{

CommandLineParser parser;

if (isatty(fileno(stdin)) && _argc == 1)

{

// If the terminal is taking input from the user, provide more user-friendly output.

CommandLineParser::printHelp(sout());

// In this case we want to exit with an error but not display any error message.

return false;

}

try

{

parser.parse(_argc, _argv);

}

catch (...)

{

// Even if the overall CLI parsing fails, the --color/--no-color options may have been

// successfully parsed, and if so, should be taken into account when printing errors.

// If no value is present, it's possible that --no-color is still there but parsing failed

// due to other, unrecognized options so play it safe and disable color in that case.

m_options.formatting.coloredOutput = parser.options().formatting.coloredOutput.value_or(false);

throw;

}

m_options = parser.options();

return true;

{

if (m_options.output.evmVersion < EVMVersion::constantinople())

report(

Error::Severity::Warning,

"Support for EVM versions older than constantinople is deprecated and will be removed in the future."

);

switch (m_options.input.mode)

{

case InputMode::Help:

CommandLineParser::printHelp(sout());

break;

case InputMode::License:

printLicense();

break;

case InputMode::Version:

printVersion();

break;

case InputMode::StandardJson:

{

solAssert(m_standardJsonInput.has_value());

StandardCompiler compiler(m_universalCallback.callback(), m_options.formatting.json);

sout() << compiler.compile(std::move(m_standardJsonInput.value())) << std::endl;

m_standardJsonInput.reset();

break;

}

case InputMode::LanguageServer:

serveLSP();

break;

case InputMode::Assembler:

assembleYul(m_options.assembly.inputLanguage, m_options.assembly.targetMachine);

break;

case InputMode::Linker:

link();

writeLinkedFiles();

break;

case InputMode::Compiler:

case InputMode::CompilerWithASTImport:

compile();

outputCompilationResults();

break;

case InputMode::EVMAssemblerJSON:

assembleFromEVMAssemblyJSON();

handleCombinedJSON();

handleBytecode(m_assemblyStack->contractNames().front());

handleEVMAssembly(m_assemblyStack->contractNames().front());

break;

}

{

sout() << "solc, the solidity compiler commandline interface" << std::endl;

sout() << "Version: " << solidity::frontend::VersionString << std::endl;

{

sout() << otherLicenses << std::endl;

// This is a static variable generated by cmake from LICENSE.txt

sout() << licenseText << std::endl;

{

solAssert(m_options.input.mode == InputMode::EVMAssemblerJSON);

solAssert(!m_assemblyStack);

solAssert(!m_evmAssemblyStack && !m_compiler);

solAssert(m_fileReader.sourceUnits().size() == 1);

auto&& [sourceUnitName, source] = *m_fileReader.sourceUnits().begin();

auto evmAssemblyStack = std::make_unique<evmasm::EVMAssemblyStack>(m_options.output.evmVersion);

try

{

evmAssemblyStack->parseAndAnalyze(sourceUnitName, source);

}

catch (evmasm::AssemblyImportException const& _exception)

{

solThrow(CommandLineExecutionError, "Assembly Import Error: "s + _exception.what());

}

if (m_options.output.debugInfoSelection.has_value())

evmAssemblyStack->selectDebugInfo(m_options.output.debugInfoSelection.value());

evmAssemblyStack->assemble();

m_evmAssemblyStack = std::move(evmAssemblyStack);

m_assemblyStack = m_evmAssemblyStack.get();

{

solAssert(CompilerInputModes.count(m_options.input.mode) == 1);

solAssert(!m_assemblyStack);

solAssert(!m_evmAssemblyStack && !m_compiler);

m_compiler = std::make_unique<CompilerStack>(m_universalCallback.callback());

m_assemblyStack = m_compiler.get();

SourceReferenceFormatter formatter(serr(false), *m_compiler, coloredOutput(m_options), m_options.formatting.withErrorIds);

try

{

if (m_options.metadata.literalSources)

m_compiler->useMetadataLiteralSources(true);

m_compiler->setMetadataFormat(m_options.metadata.format);

m_compiler->setMetadataHash(m_options.metadata.hash);

if (m_options.modelChecker.initialize)

m_compiler->setModelCheckerSettings(m_options.modelChecker.settings);

m_compiler->setRemappings(m_options.input.remappings);

m_compiler->setLibraries(m_options.linker.libraries);

m_compiler->setViaIR(m_options.output.viaIR);

m_compiler->setEVMVersion(m_options.output.evmVersion);

m_compiler->setEOFVersion(m_options.output.eofVersion);

m_compiler->setRevertStringBehaviour(m_options.output.revertStrings);

if (m_options.output.debugInfoSelection.has_value())

m_compiler->selectDebugInfo(m_options.output.debugInfoSelection.value());

// TODO: Perhaps we should not compile unless requested

m_compiler->enableIRGeneration(

m_options.compiler.outputs.ir ||

m_options.compiler.outputs.irOptimized ||

m_options.compiler.outputs.irAstJson ||

m_options.compiler.outputs.irOptimizedAstJson

);

m_compiler->enableEvmBytecodeGeneration(

m_options.compiler.estimateGas ||

m_options.compiler.outputs.asm_ ||

m_options.compiler.outputs.asmJson ||

m_options.compiler.outputs.opcodes ||

m_options.compiler.outputs.binary ||

m_options.compiler.outputs.binaryRuntime ||

(m_options.compiler.combinedJsonRequests && (

m_options.compiler.combinedJsonRequests->binary ||

m_options.compiler.combinedJsonRequests->binaryRuntime ||

m_options.compiler.combinedJsonRequests->opcodes ||

m_options.compiler.combinedJsonRequests->asm_ ||

m_options.compiler.combinedJsonRequests->generatedSources ||

m_options.compiler.combinedJsonRequests->generatedSourcesRuntime ||

m_options.compiler.combinedJsonRequests->srcMap ||

m_options.compiler.combinedJsonRequests->srcMapRuntime ||

m_options.compiler.combinedJsonRequests->funDebug ||

m_options.compiler.combinedJsonRequests->funDebugRuntime

))

);

m_compiler->setOptimiserSettings(m_options.optimiserSettings());

if (m_options.input.mode == InputMode::CompilerWithASTImport)

{

try

{

m_compiler->importASTs(parseAstFromInput());

if (!m_compiler->analyze())

{

formatter.printErrorInformation(m_compiler->errors());

astAssert(false, "Analysis of the AST failed");

}

}

catch (Exception const& _exc)

{

// FIXME: AST import is missing proper validations. This hack catches failing

// assertions and presents them as if they were compiler errors.

solThrow(CommandLineExecutionError, "Failed to import AST: "s + _exc.what());

}

}

else

m_compiler->setSources(m_fileReader.sourceUnits());

bool successful = m_compiler->compile(m_options.output.stopAfter);

for (auto const& error: m_compiler->errors())

{

m_hasOutput = true;

formatter.printErrorInformation(*error);

}

if (!successful)

solThrow(CommandLineExecutionError, "");

}

catch (CompilerError const& _exception)

{

m_hasOutput = true;

formatter.printExceptionInformation(

_exception,

Error::errorSeverity(Error::Type::CompilerError)

);

solThrow(CommandLineExecutionError, "");

}

catch (Error const& _error)

{

if (_error.type() == Error::Type::DocstringParsingError)

{

report(Error::Severity::Error, *boost::get_error_info<errinfo_comment>(_error));

solThrow(CommandLineExecutionError, "Documentation parsing failed.");

}

else

{

m_hasOutput = true;

formatter.printErrorInformation(_error);

solThrow(CommandLineExecutionError, "");

}

}

{

solAssert(m_assemblyStack);

solAssert(

CompilerInputModes.count(m_options.input.mode) == 1 ||

m_options.input.mode == frontend::InputMode::EVMAssemblerJSON

);

if (!m_options.compiler.combinedJsonRequests.has_value())

return;

Json::Value output(Json::objectValue);

output[g_strVersion] = frontend::VersionString;

std::vector<std::string> contracts = m_assemblyStack->contractNames();

if (!contracts.empty())

output[g_strContracts] = Json::Value(Json::objectValue);

for (std::string const& contractName: contracts)

{

Json::Value& contractData = output[g_strContracts][contractName] = Json::objectValue;

// NOTE: The state checks here are more strict that in Standard JSON. There we allow

// requesting certain outputs even if compilation fails as long as analysis went ok.

if (m_compiler && m_compiler->compilationSuccessful())

{

if (m_options.compiler.combinedJsonRequests->abi)

contractData[g_strAbi] = m_compiler->contractABI(contractName);

if (m_options.compiler.combinedJsonRequests->metadata)

contractData["metadata"] = m_compiler->metadata(contractName);

if (m_options.compiler.combinedJsonRequests->storageLayout)

contractData[g_strStorageLayout] = m_compiler->storageLayout(contractName);

if (m_options.compiler.combinedJsonRequests->generatedSources)

contractData[g_strGeneratedSources] = m_compiler->generatedSources(contractName, false);

if (m_options.compiler.combinedJsonRequests->generatedSourcesRuntime)

contractData[g_strGeneratedSourcesRuntime] = m_compiler->generatedSources(contractName, true);

if (m_options.compiler.combinedJsonRequests->signatureHashes)

contractData[g_strSignatureHashes] = m_compiler->interfaceSymbols(contractName)["methods"];

if (m_options.compiler.combinedJsonRequests->natspecDev)

contractData[g_strNatspecDev] = m_compiler->natspecDev(contractName);

if (m_options.compiler.combinedJsonRequests->natspecUser)

contractData[g_strNatspecUser] = m_compiler->natspecUser(contractName);

}

if (m_assemblyStack->compilationSuccessful())

{

if (m_options.compiler.combinedJsonRequests->binary)

contractData[g_strBinary] = m_assemblyStack->object(contractName).toHex();

if (m_options.compiler.combinedJsonRequests->binaryRuntime)

contractData[g_strBinaryRuntime] = m_assemblyStack->runtimeObject(contractName).toHex();

if (m_options.compiler.combinedJsonRequests->opcodes)

contractData[g_strOpcodes] = evmasm::disassemble(m_assemblyStack->object(contractName).bytecode, m_options.output.evmVersion);

if (m_options.compiler.combinedJsonRequests->asm_)

contractData[g_strAsm] = m_assemblyStack->assemblyJSON(contractName);

if (m_options.compiler.combinedJsonRequests->srcMap)

{

auto map = m_assemblyStack->sourceMapping(contractName);

contractData[g_strSrcMap] = map ? *map : "";

}

if (m_options.compiler.combinedJsonRequests->srcMapRuntime)

{

auto map = m_assemblyStack->runtimeSourceMapping(contractName);

contractData[g_strSrcMapRuntime] = map ? *map : "";

}

if (m_options.compiler.combinedJsonRequests->funDebug)