mirror of
https://github.com/ethereum/solidity
synced 2023-10-03 13:03:40 +00:00
Merge pull request #14514 from junaire/solc-namespace-std
Purge using namespace std from solc
This commit is contained in:
Nikola Matić
GitHub
commit
589adee306
@ -34,6 +34,7 @@ NAMESPACE_STD_FREE_FILES=(
|
||||
libsolidity/lsp/*
|
||||
libsolidity/parsing/*
|
||||
libsolutil/*
|
||||
solc/*
|
||||
)
|
||||
|
||||
(
|
||||
|
||||
@ -81,8 +81,7 @@
|
||||
#define STDERR_FILENO 2
|
||||
#endif
|
||||
|
||||
|
||||
using namespace std;
|
||||
using namespace std::string_literals;
|
||||
using namespace solidity;
|
||||
using namespace solidity::util;
|
||||
using namespace solidity::langutil;
|
||||
@ -90,7 +89,7 @@ using namespace solidity::langutil;
|
||||
namespace
|
||||
{
|
||||
|
||||
set<frontend::InputMode> const CompilerInputModes{
|
||||
std::set<frontend::InputMode> const CompilerInputModes{
|
||||
frontend::InputMode::Compiler,
|
||||
frontend::InputMode::CompilerWithASTImport,
|
||||
};
|
||||
@ -100,14 +99,14 @@ set<frontend::InputMode> const CompilerInputModes{
|
||||
namespace solidity::frontend
|
||||
{
|
||||
|
||||
ostream& CommandLineInterface::sout(bool _markAsUsed)
|
||||
std::ostream& CommandLineInterface::sout(bool _markAsUsed)
|
||||
{
|
||||
if (_markAsUsed)
|
||||
m_hasOutput = true;
|
||||
return m_sout;
|
||||
}
|
||||
|
||||
ostream& CommandLineInterface::serr(bool _markAsUsed)
|
||||
std::ostream& CommandLineInterface::serr(bool _markAsUsed)
|
||||
{
|
||||
if (_markAsUsed)
|
||||
m_hasOutput = true;
|
||||
@ -118,27 +117,27 @@ ostream& CommandLineInterface::serr(bool _markAsUsed)
|
||||
#define cout
|
||||
#define cerr
|
||||
|
||||
static string const g_stdinFileName = "<stdin>";
|
||||
static string const g_strAbi = "abi";
|
||||
static string const g_strAsm = "asm";
|
||||
static string const g_strAst = "ast";
|
||||
static string const g_strBinary = "bin";
|
||||
static string const g_strBinaryRuntime = "bin-runtime";
|
||||
static string const g_strContracts = "contracts";
|
||||
static string const g_strFunDebug = "function-debug";
|
||||
static string const g_strFunDebugRuntime = "function-debug-runtime";
|
||||
static string const g_strGeneratedSources = "generated-sources";
|
||||
static string const g_strGeneratedSourcesRuntime = "generated-sources-runtime";
|
||||
static string const g_strNatspecDev = "devdoc";
|
||||
static string const g_strNatspecUser = "userdoc";
|
||||
static string const g_strOpcodes = "opcodes";
|
||||
static string const g_strSignatureHashes = "hashes";
|
||||
static string const g_strSourceList = "sourceList";
|
||||
static string const g_strSources = "sources";
|
||||
static string const g_strSrcMap = "srcmap";
|
||||
static string const g_strSrcMapRuntime = "srcmap-runtime";
|
||||
static string const g_strStorageLayout = "storage-layout";
|
||||
static string const g_strVersion = "version";
|
||||
static std::string const g_stdinFileName = "<stdin>";
|
||||
static std::string const g_strAbi = "abi";
|
||||
static std::string const g_strAsm = "asm";
|
||||
static std::string const g_strAst = "ast";
|
||||
static std::string const g_strBinary = "bin";
|
||||
static std::string const g_strBinaryRuntime = "bin-runtime";
|
||||
static std::string const g_strContracts = "contracts";
|
||||
static std::string const g_strFunDebug = "function-debug";
|
||||
static std::string const g_strFunDebugRuntime = "function-debug-runtime";
|
||||
static std::string const g_strGeneratedSources = "generated-sources";
|
||||
static std::string const g_strGeneratedSourcesRuntime = "generated-sources-runtime";
|
||||
static std::string const g_strNatspecDev = "devdoc";
|
||||
static std::string const g_strNatspecUser = "userdoc";
|
||||
static std::string const g_strOpcodes = "opcodes";
|
||||
static std::string const g_strSignatureHashes = "hashes";
|
||||
static std::string const g_strSourceList = "sourceList";
|
||||
static std::string const g_strSources = "sources";
|
||||
static std::string const g_strSrcMap = "srcmap";
|
||||
static std::string const g_strSrcMapRuntime = "srcmap-runtime";
|
||||
static std::string const g_strStorageLayout = "storage-layout";
|
||||
static std::string const g_strVersion = "version";
|
||||
|
||||
static bool needsHumanTargetedStdout(CommandLineOptions const& _options)
|
||||
{
|
||||
@ -167,7 +166,7 @@ static bool coloredOutput(CommandLineOptions const& _options)
|
||||
(_options.formatting.coloredOutput.has_value() && _options.formatting.coloredOutput.value());
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleBinary(string const& _contract)
|
||||
void CommandLineInterface::handleBinary(std::string const& _contract)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
@ -177,8 +176,8 @@ void CommandLineInterface::handleBinary(string const& _contract)
|
||||
createFile(m_compiler->filesystemFriendlyName(_contract) + ".bin", objectWithLinkRefsHex(m_compiler->object(_contract)));
|
||||
else
|
||||
{
|
||||
sout() << "Binary:" << endl;
|
||||
sout() << objectWithLinkRefsHex(m_compiler->object(_contract)) << endl;
|
||||
sout() << "Binary:" << std::endl;
|
||||
sout() << objectWithLinkRefsHex(m_compiler->object(_contract)) << std::endl;
|
||||
}
|
||||
}
|
||||
if (m_options.compiler.outputs.binaryRuntime)
|
||||
@ -187,13 +186,13 @@ void CommandLineInterface::handleBinary(string const& _contract)
|
||||
createFile(m_compiler->filesystemFriendlyName(_contract) + ".bin-runtime", objectWithLinkRefsHex(m_compiler->runtimeObject(_contract)));
|
||||
else
|
||||
{
|
||||
sout() << "Binary of the runtime part:" << endl;
|
||||
sout() << objectWithLinkRefsHex(m_compiler->runtimeObject(_contract)) << endl;
|
||||
sout() << "Binary of the runtime part:" << std::endl;
|
||||
sout() << objectWithLinkRefsHex(m_compiler->runtimeObject(_contract)) << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleOpcode(string const& _contract)
|
||||
void CommandLineInterface::handleOpcode(std::string const& _contract)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
@ -201,13 +200,13 @@ void CommandLineInterface::handleOpcode(string const& _contract)
|
||||
createFile(m_compiler->filesystemFriendlyName(_contract) + ".opcode", evmasm::disassemble(m_compiler->object(_contract).bytecode, m_options.output.evmVersion));
|
||||
else
|
||||
{
|
||||
sout() << "Opcodes:" << endl;
|
||||
sout() << uppercase << evmasm::disassemble(m_compiler->object(_contract).bytecode, m_options.output.evmVersion);
|
||||
sout() << endl;
|
||||
sout() << "Opcodes:" << std::endl;
|
||||
sout() << std::uppercase << evmasm::disassemble(m_compiler->object(_contract).bytecode, m_options.output.evmVersion);
|
||||
sout() << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleIR(string const& _contractName)
|
||||
void CommandLineInterface::handleIR(std::string const& _contractName)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
@ -218,12 +217,12 @@ void CommandLineInterface::handleIR(string const& _contractName)
|
||||
createFile(m_compiler->filesystemFriendlyName(_contractName) + ".yul", m_compiler->yulIR(_contractName));
|
||||
else
|
||||
{
|
||||
sout() << "IR:" << endl;
|
||||
sout() << m_compiler->yulIR(_contractName) << endl;
|
||||
sout() << "IR:" << std::endl;
|
||||
sout() << m_compiler->yulIR(_contractName) << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleIRAst(string const& _contractName)
|
||||
void CommandLineInterface::handleIRAst(std::string const& _contractName)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
@ -240,15 +239,15 @@ void CommandLineInterface::handleIRAst(string const& _contractName)
|
||||
);
|
||||
else
|
||||
{
|
||||
sout() << "IR AST:" << endl;
|
||||
sout() << "IR AST:" << std::endl;
|
||||
sout() << util::jsonPrint(
|
||||
m_compiler->yulIRAst(_contractName),
|
||||
m_options.formatting.json
|
||||
) << endl;
|
||||
) << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleIROptimized(string const& _contractName)
|
||||
void CommandLineInterface::handleIROptimized(std::string const& _contractName)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
@ -262,12 +261,12 @@ void CommandLineInterface::handleIROptimized(string const& _contractName)
|
||||
);
|
||||
else
|
||||
{
|
||||
sout() << "Optimized IR:" << endl;
|
||||
sout() << m_compiler->yulIROptimized(_contractName) << endl;
|
||||
sout() << "Optimized IR:" << std::endl;
|
||||
sout() << m_compiler->yulIROptimized(_contractName) << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleIROptimizedAst(string const& _contractName)
|
||||
void CommandLineInterface::handleIROptimizedAst(std::string const& _contractName)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
@ -284,15 +283,15 @@ void CommandLineInterface::handleIROptimizedAst(string const& _contractName)
|
||||
);
|
||||
else
|
||||
{
|
||||
sout() << "Optimized IR AST:" << endl;
|
||||
sout() << "Optimized IR AST:" << std::endl;
|
||||
sout() << util::jsonPrint(
|
||||
m_compiler->yulIROptimizedAst(_contractName),
|
||||
m_options.formatting.json
|
||||
) << endl;
|
||||
) << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleBytecode(string const& _contract)
|
||||
void CommandLineInterface::handleBytecode(std::string const& _contract)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
@ -302,7 +301,7 @@ void CommandLineInterface::handleBytecode(string const& _contract)
|
||||
handleBinary(_contract);
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleSignatureHashes(string const& _contract)
|
||||
void CommandLineInterface::handleSignatureHashes(std::string const& _contract)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
@ -310,7 +309,7 @@ void CommandLineInterface::handleSignatureHashes(string const& _contract)
|
||||
return;
|
||||
|
||||
Json::Value interfaceSymbols = m_compiler->interfaceSymbols(_contract);
|
||||
string out = "Function signatures:\n";
|
||||
std::string out = "Function signatures:\n";
|
||||
for (auto const& name: interfaceSymbols["methods"].getMemberNames())
|
||||
out += interfaceSymbols["methods"][name].asString() + ": " + name + "\n";
|
||||
|
||||
@ -334,55 +333,55 @@ void CommandLineInterface::handleSignatureHashes(string const& _contract)
|
||||
sout() << out;
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleMetadata(string const& _contract)
|
||||
void CommandLineInterface::handleMetadata(std::string const& _contract)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
if (!m_options.compiler.outputs.metadata)
|
||||
return;
|
||||
|
||||
string data = m_compiler->metadata(_contract);
|
||||
std::string data = m_compiler->metadata(_contract);
|
||||
if (!m_options.output.dir.empty())
|
||||
createFile(m_compiler->filesystemFriendlyName(_contract) + "_meta.json", data);
|
||||
else
|
||||
sout() << "Metadata:" << endl << data << endl;
|
||||
sout() << "Metadata:" << std::endl << data << std::endl;
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleABI(string const& _contract)
|
||||
void CommandLineInterface::handleABI(std::string const& _contract)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
if (!m_options.compiler.outputs.abi)
|
||||
return;
|
||||
|
||||
string data = jsonPrint(removeNullMembers(m_compiler->contractABI(_contract)), m_options.formatting.json);
|
||||
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" << endl << data << endl;
|
||||
sout() << "Contract JSON ABI" << std::endl << data << std::endl;
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleStorageLayout(string const& _contract)
|
||||
void CommandLineInterface::handleStorageLayout(std::string const& _contract)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
if (!m_options.compiler.outputs.storageLayout)
|
||||
return;
|
||||
|
||||
string data = jsonPrint(removeNullMembers(m_compiler->storageLayout(_contract)), m_options.formatting.json);
|
||||
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:" << endl << data << endl;
|
||||
sout() << "Contract Storage Layout:" << std::endl << data << std::endl;
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleNatspec(bool _natspecDev, string const& _contract)
|
||||
void CommandLineInterface::handleNatspec(bool _natspecDev, std::string const& _contract)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
bool enabled = false;
|
||||
string suffix;
|
||||
string title;
|
||||
std::string suffix;
|
||||
std::string title;
|
||||
|
||||
if (_natspecDev)
|
||||
{
|
||||
@ -399,7 +398,7 @@ void CommandLineInterface::handleNatspec(bool _natspecDev, string const& _contra
|
||||
|
||||
if (enabled)
|
||||
{
|
||||
string output = jsonPrint(
|
||||
std::string output = jsonPrint(
|
||||
removeNullMembers(
|
||||
_natspecDev ?
|
||||
m_compiler->natspecDev(_contract) :
|
||||
@ -412,51 +411,51 @@ void CommandLineInterface::handleNatspec(bool _natspecDev, string const& _contra
|
||||
createFile(m_compiler->filesystemFriendlyName(_contract) + suffix, output);
|
||||
else
|
||||
{
|
||||
sout() << title << endl;
|
||||
sout() << output << endl;
|
||||
sout() << title << std::endl;
|
||||
sout() << output << std::endl;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleGasEstimation(string const& _contract)
|
||||
void CommandLineInterface::handleGasEstimation(std::string const& _contract)
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
Json::Value estimates = m_compiler->gasEstimates(_contract);
|
||||
sout() << "Gas estimation:" << endl;
|
||||
sout() << "Gas estimation:" << std::endl;
|
||||
|
||||
if (estimates["creation"].isObject())
|
||||
{
|
||||
Json::Value creation = estimates["creation"];
|
||||
sout() << "construction:" << endl;
|
||||
sout() << "construction:" << std::endl;
|
||||
sout() << " " << creation["executionCost"].asString();
|
||||
sout() << " + " << creation["codeDepositCost"].asString();
|
||||
sout() << " = " << creation["totalCost"].asString() << endl;
|
||||
sout() << " = " << creation["totalCost"].asString() << std::endl;
|
||||
}
|
||||
|
||||
if (estimates["external"].isObject())
|
||||
{
|
||||
Json::Value externalFunctions = estimates["external"];
|
||||
sout() << "external:" << endl;
|
||||
sout() << "external:" << std::endl;
|
||||
for (auto const& name: externalFunctions.getMemberNames())
|
||||
{
|
||||
if (name.empty())
|
||||
sout() << " fallback:\t";
|
||||
else
|
||||
sout() << " " << name << ":\t";
|
||||
sout() << externalFunctions[name].asString() << endl;
|
||||
sout() << externalFunctions[name].asString() << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
if (estimates["internal"].isObject())
|
||||
{
|
||||
Json::Value internalFunctions = estimates["internal"];
|
||||
sout() << "internal:" << endl;
|
||||
sout() << "internal:" << std::endl;
|
||||
for (auto const& name: internalFunctions.getMemberNames())
|
||||
{
|
||||
sout() << " " << name << ":\t";
|
||||
sout() << internalFunctions[name].asString() << endl;
|
||||
sout() << internalFunctions[name].asString() << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -465,7 +464,7 @@ void CommandLineInterface::readInputFiles()
|
||||
{
|
||||
solAssert(!m_standardJsonInput.has_value());
|
||||
|
||||
static set<frontend::InputMode> const noInputFiles{
|
||||
static std::set<frontend::InputMode> const noInputFiles{
|
||||
frontend::InputMode::Help,
|
||||
frontend::InputMode::License,
|
||||
frontend::InputMode::Version
|
||||
@ -491,13 +490,13 @@ void CommandLineInterface::readInputFiles()
|
||||
for (boost::filesystem::path const& allowedDirectory: m_options.input.allowedDirectories)
|
||||
m_fileReader.allowDirectory(allowedDirectory);
|
||||
|
||||
map<string, set<boost::filesystem::path>> collisions =
|
||||
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() + "\""; };
|
||||
|
||||
string message =
|
||||
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";
|
||||
@ -518,7 +517,7 @@ void CommandLineInterface::readInputFiles()
|
||||
if (!m_options.input.ignoreMissingFiles)
|
||||
solThrow(CommandLineValidationError, '"' + infile.string() + "\" is not found.");
|
||||
else
|
||||
serr() << infile << " is not found. Skipping." << endl;
|
||||
serr() << infile << " is not found. Skipping." << std::endl;
|
||||
|
||||
continue;
|
||||
}
|
||||
@ -528,13 +527,13 @@ void CommandLineInterface::readInputFiles()
|
||||
if (!m_options.input.ignoreMissingFiles)
|
||||
solThrow(CommandLineValidationError, '"' + infile.string() + "\" is not a valid file.");
|
||||
else
|
||||
serr() << infile << " is not a valid file. Skipping." << endl;
|
||||
serr() << infile << " is not a valid file. Skipping." << std::endl;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// NOTE: we ignore the FileNotFound exception as we manually check above
|
||||
string fileContent = readFileAsString(infile);
|
||||
std::string fileContent = readFileAsString(infile);
|
||||
if (m_options.input.mode == InputMode::StandardJson)
|
||||
{
|
||||
solAssert(!m_standardJsonInput.has_value());
|
||||
@ -566,12 +565,12 @@ void CommandLineInterface::readInputFiles()
|
||||
solThrow(CommandLineValidationError, "All specified input files either do not exist or are not regular files.");
|
||||
}
|
||||
|
||||
map<string, Json::Value> CommandLineInterface::parseAstFromInput()
|
||||
std::map<std::string, Json::Value> CommandLineInterface::parseAstFromInput()
|
||||
{
|
||||
solAssert(m_options.input.mode == InputMode::CompilerWithASTImport);
|
||||
|
||||
map<string, Json::Value> sourceJsons;
|
||||
map<string, string> tmpSources;
|
||||
std::map<std::string, Json::Value> sourceJsons;
|
||||
std::map<std::string, std::string> tmpSources;
|
||||
|
||||
for (SourceCode const& sourceCode: m_fileReader.sourceUnits() | ranges::views::values)
|
||||
{
|
||||
@ -581,7 +580,7 @@ map<string, Json::Value> CommandLineInterface::parseAstFromInput()
|
||||
|
||||
for (auto& src: ast["sources"].getMemberNames())
|
||||
{
|
||||
string astKey = ast["sources"][src].isMember("ast") ? "ast" : "AST";
|
||||
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'");
|
||||
@ -596,7 +595,7 @@ map<string, Json::Value> CommandLineInterface::parseAstFromInput()
|
||||
return sourceJsons;
|
||||
}
|
||||
|
||||
void CommandLineInterface::createFile(string const& _fileName, string const& _data)
|
||||
void CommandLineInterface::createFile(std::string const& _fileName, std::string const& _data)
|
||||
{
|
||||
namespace fs = boost::filesystem;
|
||||
|
||||
@ -607,19 +606,19 @@ void CommandLineInterface::createFile(string const& _fileName, string const& _da
|
||||
// The simplest workaround is to use an absolute path.
|
||||
fs::create_directories(fs::absolute(m_options.output.dir));
|
||||
|
||||
string pathName = (m_options.output.dir / _fileName).string();
|
||||
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).");
|
||||
|
||||
ofstream outFile(pathName);
|
||||
std::ofstream outFile(pathName);
|
||||
outFile << _data;
|
||||
if (!outFile)
|
||||
solThrow(CommandLineOutputError, "Could not write to file \"" + pathName + "\".");
|
||||
}
|
||||
|
||||
void CommandLineInterface::createJson(string const& _fileName, string const& _json)
|
||||
void CommandLineInterface::createJson(std::string const& _fileName, std::string const& _json)
|
||||
{
|
||||
createFile(boost::filesystem::path(_fileName).stem().string() + string(".json"), _json);
|
||||
createFile(boost::filesystem::path(_fileName).stem().string() + std::string(".json"), _json);
|
||||
}
|
||||
|
||||
bool CommandLineInterface::run(int _argc, char const* const* _argv)
|
||||
@ -640,7 +639,7 @@ bool CommandLineInterface::run(int _argc, char const* const* _argv)
|
||||
// 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)
|
||||
serr() << _exception.what() << endl;
|
||||
serr() << _exception.what() << std::endl;
|
||||
|
||||
return false;
|
||||
}
|
||||
@ -683,7 +682,7 @@ void CommandLineInterface::processInput()
|
||||
solAssert(m_standardJsonInput.has_value());
|
||||
|
||||
StandardCompiler compiler(m_universalCallback.callback(), m_options.formatting.json);
|
||||
sout() << compiler.compile(std::move(m_standardJsonInput.value())) << endl;
|
||||
sout() << compiler.compile(std::move(m_standardJsonInput.value())) << std::endl;
|
||||
m_standardJsonInput.reset();
|
||||
break;
|
||||
}
|
||||
@ -707,22 +706,22 @@ void CommandLineInterface::processInput()
|
||||
|
||||
void CommandLineInterface::printVersion()
|
||||
{
|
||||
sout() << "solc, the solidity compiler commandline interface" << endl;
|
||||
sout() << "Version: " << solidity::frontend::VersionString << endl;
|
||||
sout() << "solc, the solidity compiler commandline interface" << std::endl;
|
||||
sout() << "Version: " << solidity::frontend::VersionString << std::endl;
|
||||
}
|
||||
|
||||
void CommandLineInterface::printLicense()
|
||||
{
|
||||
sout() << otherLicenses << endl;
|
||||
sout() << otherLicenses << std::endl;
|
||||
// This is a static variable generated by cmake from LICENSE.txt
|
||||
sout() << licenseText << endl;
|
||||
sout() << licenseText << std::endl;
|
||||
}
|
||||
|
||||
void CommandLineInterface::compile()
|
||||
{
|
||||
solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
|
||||
|
||||
m_compiler = make_unique<CompilerStack>(m_universalCallback.callback());
|
||||
m_compiler = std::make_unique<CompilerStack>(m_universalCallback.callback());
|
||||
|
||||
SourceReferenceFormatter formatter(serr(false), *m_compiler, coloredOutput(m_options), m_options.formatting.withErrorIds);
|
||||
|
||||
@ -840,7 +839,7 @@ void CommandLineInterface::handleCombinedJSON()
|
||||
Json::Value output(Json::objectValue);
|
||||
|
||||
output[g_strVersion] = frontend::VersionString;
|
||||
vector<string> contracts = m_compiler->contractNames();
|
||||
std::vector<std::string> contracts = m_compiler->contractNames();
|
||||
|
||||
// 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.
|
||||
@ -848,7 +847,7 @@ void CommandLineInterface::handleCombinedJSON()
|
||||
|
||||
if (!contracts.empty())
|
||||
output[g_strContracts] = Json::Value(Json::objectValue);
|
||||
for (string const& contractName: contracts)
|
||||
for (std::string const& contractName: contracts)
|
||||
{
|
||||
Json::Value& contractData = output[g_strContracts][contractName] = Json::objectValue;
|
||||
if (m_options.compiler.combinedJsonRequests->abi && compilationSuccess)
|
||||
@ -922,11 +921,11 @@ void CommandLineInterface::handleCombinedJSON()
|
||||
}
|
||||
}
|
||||
|
||||
string json = jsonPrint(removeNullMembers(std::move(output)), m_options.formatting.json);
|
||||
std::string json = jsonPrint(removeNullMembers(std::move(output)), m_options.formatting.json);
|
||||
if (!m_options.output.dir.empty())
|
||||
createJson("combined", json);
|
||||
else
|
||||
sout() << json << endl;
|
||||
sout() << json << std::endl;
|
||||
}
|
||||
|
||||
void CommandLineInterface::handleAst()
|
||||
@ -936,7 +935,7 @@ void CommandLineInterface::handleAst()
|
||||
if (!m_options.compiler.outputs.astCompactJson)
|
||||
return;
|
||||
|
||||
vector<ASTNode const*> asts;
|
||||
std::vector<ASTNode const*> asts;
|
||||
for (auto const& sourceCode: m_fileReader.sourceUnits())
|
||||
asts.push_back(&m_compiler->ast(sourceCode.first));
|
||||
|
||||
@ -944,8 +943,8 @@ void CommandLineInterface::handleAst()
|
||||
{
|
||||
for (auto const& sourceCode: m_fileReader.sourceUnits())
|
||||
{
|
||||
stringstream data;
|
||||
string postfix = "";
|
||||
std::stringstream data;
|
||||
std::string postfix = "";
|
||||
ASTJsonExporter(m_compiler->state(), m_compiler->sourceIndices()).print(data, m_compiler->ast(sourceCode.first), m_options.formatting.json);
|
||||
postfix += "_json";
|
||||
boost::filesystem::path path(sourceCode.first);
|
||||
@ -954,10 +953,10 @@ void CommandLineInterface::handleAst()
|
||||
}
|
||||
else
|
||||
{
|
||||
sout() << "JSON AST (compact format):" << endl << endl;
|
||||
sout() << "JSON AST (compact format):" << std::endl << std::endl;
|
||||
for (auto const& sourceCode: m_fileReader.sourceUnits())
|
||||
{
|
||||
sout() << endl << "======= " << sourceCode.first << " =======" << endl;
|
||||
sout() << std::endl << "======= " << sourceCode.first << " =======" << std::endl;
|
||||
ASTJsonExporter(m_compiler->state(), m_compiler->sourceIndices()).print(sout(), m_compiler->ast(sourceCode.first), m_options.formatting.json);
|
||||
}
|
||||
}
|
||||
@ -975,11 +974,11 @@ void CommandLineInterface::link()
|
||||
solAssert(m_options.input.mode == InputMode::Linker);
|
||||
|
||||
// Map from how the libraries will be named inside the bytecode to their addresses.
|
||||
map<string, h160> librariesReplacements;
|
||||
std::map<std::string, h160> librariesReplacements;
|
||||
int const placeholderSize = 40; // 20 bytes or 40 hex characters
|
||||
for (auto const& library: m_options.linker.libraries)
|
||||
{
|
||||
string const& name = library.first;
|
||||
std::string const& name = library.first;
|
||||
// Library placeholders are 40 hex digits (20 bytes) that start and end with '__'.
|
||||
// This leaves 36 characters for the library identifier. The identifier used to
|
||||
// be just the cropped or '_'-padded library name, but this changed to
|
||||
@ -987,7 +986,7 @@ void CommandLineInterface::link()
|
||||
// We support both ways of linking here.
|
||||
librariesReplacements["__" + evmasm::LinkerObject::libraryPlaceholder(name) + "__"] = library.second;
|
||||
|
||||
string replacement = "__";
|
||||
std::string replacement = "__";
|
||||
for (size_t i = 0; i < placeholderSize - 4; ++i)
|
||||
replacement.push_back(i < name.size() ? name[i] : '_');
|
||||
replacement += "__";
|
||||
@ -1010,18 +1009,18 @@ void CommandLineInterface::link()
|
||||
)
|
||||
solThrow(
|
||||
CommandLineExecutionError,
|
||||
"Error in binary object file " + src.first + " at position " + to_string(it - src.second.begin()) + "\n" +
|
||||
'"' + string(it, it + min(placeholderSize, static_cast<int>(end - it))) + "\" is not a valid link reference."
|
||||
"Error in binary object file " + src.first + " at position " + std::to_string(it - src.second.begin()) + "\n" +
|
||||
'"' + std::string(it, it + std::min(placeholderSize, static_cast<int>(end - it))) + "\" is not a valid link reference."
|
||||
);
|
||||
|
||||
string foundPlaceholder(it, it + placeholderSize);
|
||||
std::string foundPlaceholder(it, it + placeholderSize);
|
||||
if (librariesReplacements.count(foundPlaceholder))
|
||||
{
|
||||
string hexStr(util::toHex(librariesReplacements.at(foundPlaceholder).asBytes()));
|
||||
std::string hexStr(util::toHex(librariesReplacements.at(foundPlaceholder).asBytes()));
|
||||
copy(hexStr.begin(), hexStr.end(), it);
|
||||
}
|
||||
else
|
||||
serr() << "Reference \"" << foundPlaceholder << "\" in file \"" << src.first << "\" still unresolved." << endl;
|
||||
serr() << "Reference \"" << foundPlaceholder << "\" in file \"" << src.first << "\" still unresolved." << std::endl;
|
||||
it += placeholderSize;
|
||||
}
|
||||
// Remove hints for resolved libraries.
|
||||
@ -1039,25 +1038,25 @@ void CommandLineInterface::writeLinkedFiles()
|
||||
|
||||
for (auto const& src: m_fileReader.sourceUnits())
|
||||
if (src.first == g_stdinFileName)
|
||||
sout() << src.second << endl;
|
||||
sout() << src.second << std::endl;
|
||||
else
|
||||
{
|
||||
ofstream outFile(src.first);
|
||||
std::ofstream outFile(src.first);
|
||||
outFile << src.second;
|
||||
if (!outFile)
|
||||
solThrow(CommandLineOutputError, "Could not write to file " + src.first + ". Aborting.");
|
||||
}
|
||||
sout() << "Linking completed." << endl;
|
||||
sout() << "Linking completed." << std::endl;
|
||||
}
|
||||
|
||||
string CommandLineInterface::libraryPlaceholderHint(string const& _libraryName)
|
||||
std::string CommandLineInterface::libraryPlaceholderHint(std::string const& _libraryName)
|
||||
{
|
||||
return "// " + evmasm::LinkerObject::libraryPlaceholder(_libraryName) + " -> " + _libraryName;
|
||||
}
|
||||
|
||||
string CommandLineInterface::objectWithLinkRefsHex(evmasm::LinkerObject const& _obj)
|
||||
std::string CommandLineInterface::objectWithLinkRefsHex(evmasm::LinkerObject const& _obj)
|
||||
{
|
||||
string out = _obj.toHex();
|
||||
std::string out = _obj.toHex();
|
||||
if (!_obj.linkReferences.empty())
|
||||
{
|
||||
out += "\n";
|
||||
@ -1072,7 +1071,7 @@ void CommandLineInterface::assembleYul(yul::YulStack::Language _language, yul::Y
|
||||
solAssert(m_options.input.mode == InputMode::Assembler);
|
||||
|
||||
bool successful = true;
|
||||
map<string, yul::YulStack> yulStacks;
|
||||
std::map<std::string, yul::YulStack> yulStacks;
|
||||
for (auto const& src: m_fileReader.sourceUnits())
|
||||
{
|
||||
auto& stack = yulStacks[src.first] = yul::YulStack(
|
||||
@ -1114,8 +1113,8 @@ void CommandLineInterface::assembleYul(yul::YulStack::Language _language, yul::Y
|
||||
for (auto const& src: m_fileReader.sourceUnits())
|
||||
{
|
||||
solAssert(_targetMachine == yul::YulStack::Machine::EVM);
|
||||
string machine = "EVM";
|
||||
sout() << endl << "======= " << src.first << " (" << machine << ") =======" << endl;
|
||||
std::string machine = "EVM";
|
||||
sout() << std::endl << "======= " << src.first << " (" << machine << ") =======" << std::endl;
|
||||
|
||||
yul::YulStack& stack = yulStacks[src.first];
|
||||
|
||||
@ -1123,8 +1122,8 @@ void CommandLineInterface::assembleYul(yul::YulStack::Language _language, yul::Y
|
||||
{
|
||||
// NOTE: This actually outputs unoptimized code when the optimizer is disabled but
|
||||
// 'ir' output in StandardCompiler works the same way.
|
||||
sout() << endl << "Pretty printed source:" << endl;
|
||||
sout() << stack.print() << endl;
|
||||
sout() << std::endl << "Pretty printed source:" << std::endl;
|
||||
sout() << stack.print() << std::endl;
|
||||
}
|
||||
|
||||
yul::MachineAssemblyObject object;
|
||||
@ -1133,25 +1132,25 @@ void CommandLineInterface::assembleYul(yul::YulStack::Language _language, yul::Y
|
||||
|
||||
if (m_options.compiler.outputs.binary)
|
||||
{
|
||||
sout() << endl << "Binary representation:" << endl;
|
||||
sout() << std::endl << "Binary representation:" << std::endl;
|
||||
if (object.bytecode)
|
||||
sout() << object.bytecode->toHex() << endl;
|
||||
sout() << object.bytecode->toHex() << std::endl;
|
||||
else
|
||||
serr() << "No binary representation found." << endl;
|
||||
serr() << "No binary representation found." << std::endl;
|
||||
}
|
||||
if (m_options.compiler.outputs.astCompactJson)
|
||||
{
|
||||
sout() << "AST:" << endl << endl;
|
||||
sout() << util::jsonPrint(stack.astJson(), m_options.formatting.json) << endl;
|
||||
sout() << "AST:" << std::endl << std::endl;
|
||||
sout() << util::jsonPrint(stack.astJson(), m_options.formatting.json) << std::endl;
|
||||
}
|
||||
solAssert(_targetMachine == yul::YulStack::Machine::EVM, "");
|
||||
if (m_options.compiler.outputs.asm_)
|
||||
{
|
||||
sout() << endl << "Text representation:" << endl;
|
||||
sout() << std::endl << "Text representation:" << std::endl;
|
||||
if (!object.assembly.empty())
|
||||
sout() << object.assembly << endl;
|
||||
sout() << object.assembly << std::endl;
|
||||
else
|
||||
serr() << "No text representation found." << endl;
|
||||
serr() << "No text representation found." << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1173,15 +1172,15 @@ void CommandLineInterface::outputCompilationResults()
|
||||
// we can safely assume that full compilation was performed and successful.
|
||||
solAssert(m_options.output.stopAfter >= CompilerStack::State::CompilationSuccessful);
|
||||
|
||||
for (string const& contract: m_compiler->contractNames())
|
||||
for (std::string const& contract: m_compiler->contractNames())
|
||||
{
|
||||
if (needsHumanTargetedStdout(m_options))
|
||||
sout() << endl << "======= " << contract << " =======" << endl;
|
||||
sout() << std::endl << "======= " << contract << " =======" << std::endl;
|
||||
|
||||
// do we need EVM assembly?
|
||||
if (m_options.compiler.outputs.asm_ || m_options.compiler.outputs.asmJson)
|
||||
{
|
||||
string ret;
|
||||
std::string ret;
|
||||
if (m_options.compiler.outputs.asmJson)
|
||||
ret = util::jsonPrint(removeNullMembers(m_compiler->assemblyJSON(contract)), m_options.formatting.json);
|
||||
else
|
||||
@ -1190,7 +1189,7 @@ void CommandLineInterface::outputCompilationResults()
|
||||
if (!m_options.output.dir.empty())
|
||||
createFile(m_compiler->filesystemFriendlyName(contract) + (m_options.compiler.outputs.asmJson ? "_evm.json" : ".evm"), ret);
|
||||
else
|
||||
sout() << "EVM assembly:" << endl << ret << endl;
|
||||
sout() << "EVM assembly:" << std::endl << ret << std::endl;
|
||||
}
|
||||
|
||||
if (m_options.compiler.estimateGas)
|
||||
@ -1213,11 +1212,11 @@ void CommandLineInterface::outputCompilationResults()
|
||||
if (!m_hasOutput)
|
||||
{
|
||||
if (!m_options.output.dir.empty())
|
||||
sout() << "Compiler run successful. Artifact(s) can be found in directory " << m_options.output.dir << "." << endl;
|
||||
sout() << "Compiler run successful. Artifact(s) can be found in directory " << m_options.output.dir << "." << std::endl;
|
||||
else if (m_compiler->contractNames().empty())
|
||||
sout() << "Compiler run successful. No contracts to compile." << endl;
|
||||
sout() << "Compiler run successful. No contracts to compile." << std::endl;
|
||||
else
|
||||
sout() << "Compiler run successful. No output generated." << endl;
|
||||
sout() << "Compiler run successful. No output generated." << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -30,7 +30,6 @@
|
||||
#include <range/v3/view/filter.hpp>
|
||||
#include <range/v3/range/conversion.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace solidity::langutil;
|
||||
|
||||
namespace po = boost::program_options;
|
||||
@ -38,59 +37,59 @@ namespace po = boost::program_options;
|
||||
namespace solidity::frontend
|
||||
{
|
||||
|
||||
static string const g_strAllowPaths = "allow-paths";
|
||||
static string const g_strBasePath = "base-path";
|
||||
static string const g_strIncludePath = "include-path";
|
||||
static string const g_strAssemble = "assemble";
|
||||
static string const g_strCombinedJson = "combined-json";
|
||||
static string const g_strEVM = "evm";
|
||||
static string const g_strEVMVersion = "evm-version";
|
||||
static string const g_strEOFVersion = "experimental-eof-version";
|
||||
static string const g_strViaIR = "via-ir";
|
||||
static string const g_strExperimentalViaIR = "experimental-via-ir";
|
||||
static string const g_strGas = "gas";
|
||||
static string const g_strHelp = "help";
|
||||
static string const g_strImportAst = "import-ast";
|
||||
static string const g_strInputFile = "input-file";
|
||||
static string const g_strYul = "yul";
|
||||
static string const g_strYulDialect = "yul-dialect";
|
||||
static string const g_strDebugInfo = "debug-info";
|
||||
static string const g_strIPFS = "ipfs";
|
||||
static string const g_strLicense = "license";
|
||||
static string const g_strLibraries = "libraries";
|
||||
static string const g_strLink = "link";
|
||||
static string const g_strLSP = "lsp";
|
||||
static string const g_strMachine = "machine";
|
||||
static string const g_strNoCBORMetadata = "no-cbor-metadata";
|
||||
static string const g_strMetadataHash = "metadata-hash";
|
||||
static string const g_strMetadataLiteral = "metadata-literal";
|
||||
static string const g_strModelCheckerContracts = "model-checker-contracts";
|
||||
static string const g_strModelCheckerDivModNoSlacks = "model-checker-div-mod-no-slacks";
|
||||
static string const g_strModelCheckerEngine = "model-checker-engine";
|
||||
static string const g_strModelCheckerExtCalls = "model-checker-ext-calls";
|
||||
static string const g_strModelCheckerInvariants = "model-checker-invariants";
|
||||
static string const g_strModelCheckerPrintQuery = "model-checker-print-query";
|
||||
static string const g_strModelCheckerShowProvedSafe = "model-checker-show-proved-safe";
|
||||
static string const g_strModelCheckerShowUnproved = "model-checker-show-unproved";
|
||||
static string const g_strModelCheckerShowUnsupported = "model-checker-show-unsupported";
|
||||
static string const g_strModelCheckerSolvers = "model-checker-solvers";
|
||||
static string const g_strModelCheckerTargets = "model-checker-targets";
|
||||
static string const g_strModelCheckerTimeout = "model-checker-timeout";
|
||||
static string const g_strModelCheckerBMCLoopIterations = "model-checker-bmc-loop-iterations";
|
||||
static string const g_strNone = "none";
|
||||
static string const g_strNoOptimizeYul = "no-optimize-yul";
|
||||
static string const g_strOptimize = "optimize";
|
||||
static string const g_strOptimizeRuns = "optimize-runs";
|
||||
static string const g_strOptimizeYul = "optimize-yul";
|
||||
static string const g_strYulOptimizations = "yul-optimizations";
|
||||
static string const g_strOutputDir = "output-dir";
|
||||
static string const g_strOverwrite = "overwrite";
|
||||
static string const g_strRevertStrings = "revert-strings";
|
||||
static string const g_strStopAfter = "stop-after";
|
||||
static string const g_strParsing = "parsing";
|
||||
static std::string const g_strAllowPaths = "allow-paths";
|
||||
static std::string const g_strBasePath = "base-path";
|
||||
static std::string const g_strIncludePath = "include-path";
|
||||
static std::string const g_strAssemble = "assemble";
|
||||
static std::string const g_strCombinedJson = "combined-json";
|
||||
static std::string const g_strEVM = "evm";
|
||||
static std::string const g_strEVMVersion = "evm-version";
|
||||
static std::string const g_strEOFVersion = "experimental-eof-version";
|
||||
static std::string const g_strViaIR = "via-ir";
|
||||
static std::string const g_strExperimentalViaIR = "experimental-via-ir";
|
||||
static std::string const g_strGas = "gas";
|
||||
static std::string const g_strHelp = "help";
|
||||
static std::string const g_strImportAst = "import-ast";
|
||||
static std::string const g_strInputFile = "input-file";
|
||||
static std::string const g_strYul = "yul";
|
||||
static std::string const g_strYulDialect = "yul-dialect";
|
||||
static std::string const g_strDebugInfo = "debug-info";
|
||||
static std::string const g_strIPFS = "ipfs";
|
||||
static std::string const g_strLicense = "license";
|
||||
static std::string const g_strLibraries = "libraries";
|
||||
static std::string const g_strLink = "link";
|
||||
static std::string const g_strLSP = "lsp";
|
||||
static std::string const g_strMachine = "machine";
|
||||
static std::string const g_strNoCBORMetadata = "no-cbor-metadata";
|
||||
static std::string const g_strMetadataHash = "metadata-hash";
|
||||
static std::string const g_strMetadataLiteral = "metadata-literal";
|
||||
static std::string const g_strModelCheckerContracts = "model-checker-contracts";
|
||||
static std::string const g_strModelCheckerDivModNoSlacks = "model-checker-div-mod-no-slacks";
|
||||
static std::string const g_strModelCheckerEngine = "model-checker-engine";
|
||||
static std::string const g_strModelCheckerExtCalls = "model-checker-ext-calls";
|
||||
static std::string const g_strModelCheckerInvariants = "model-checker-invariants";
|
||||
static std::string const g_strModelCheckerPrintQuery = "model-checker-print-query";
|
||||
static std::string const g_strModelCheckerShowProvedSafe = "model-checker-show-proved-safe";
|
||||
static std::string const g_strModelCheckerShowUnproved = "model-checker-show-unproved";
|
||||
static std::string const g_strModelCheckerShowUnsupported = "model-checker-show-unsupported";
|
||||
static std::string const g_strModelCheckerSolvers = "model-checker-solvers";
|
||||
static std::string const g_strModelCheckerTargets = "model-checker-targets";
|
||||
static std::string const g_strModelCheckerTimeout = "model-checker-timeout";
|
||||
static std::string const g_strModelCheckerBMCLoopIterations = "model-checker-bmc-loop-iterations";
|
||||
static std::string const g_strNone = "none";
|
||||
static std::string const g_strNoOptimizeYul = "no-optimize-yul";
|
||||
static std::string const g_strOptimize = "optimize";
|
||||
static std::string const g_strOptimizeRuns = "optimize-runs";
|
||||
static std::string const g_strOptimizeYul = "optimize-yul";
|
||||
static std::string const g_strYulOptimizations = "yul-optimizations";
|
||||
static std::string const g_strOutputDir = "output-dir";
|
||||
static std::string const g_strOverwrite = "overwrite";
|
||||
static std::string const g_strRevertStrings = "revert-strings";
|
||||
static std::string const g_strStopAfter = "stop-after";
|
||||
static std::string const g_strParsing = "parsing";
|
||||
|
||||
/// Possible arguments to for --revert-strings
|
||||
static set<string> const g_revertStringsArgs
|
||||
static std::set<std::string> const g_revertStringsArgs
|
||||
{
|
||||
revertStringsToString(RevertStrings::Default),
|
||||
revertStringsToString(RevertStrings::Strip),
|
||||
@ -98,40 +97,40 @@ static set<string> const g_revertStringsArgs
|
||||
revertStringsToString(RevertStrings::VerboseDebug)
|
||||
};
|
||||
|
||||
static string const g_strSources = "sources";
|
||||
static string const g_strSourceList = "sourceList";
|
||||
static string const g_strStandardJSON = "standard-json";
|
||||
static string const g_strStrictAssembly = "strict-assembly";
|
||||
static string const g_strSwarm = "swarm";
|
||||
static string const g_strPrettyJson = "pretty-json";
|
||||
static string const g_strJsonIndent = "json-indent";
|
||||
static string const g_strVersion = "version";
|
||||
static string const g_strIgnoreMissingFiles = "ignore-missing";
|
||||
static string const g_strColor = "color";
|
||||
static string const g_strNoColor = "no-color";
|
||||
static string const g_strErrorIds = "error-codes";
|
||||
static std::string const g_strSources = "sources";
|
||||
static std::string const g_strSourceList = "sourceList";
|
||||
static std::string const g_strStandardJSON = "standard-json";
|
||||
static std::string const g_strStrictAssembly = "strict-assembly";
|
||||
static std::string const g_strSwarm = "swarm";
|
||||
static std::string const g_strPrettyJson = "pretty-json";
|
||||
static std::string const g_strJsonIndent = "json-indent";
|
||||
static std::string const g_strVersion = "version";
|
||||
static std::string const g_strIgnoreMissingFiles = "ignore-missing";
|
||||
static std::string const g_strColor = "color";
|
||||
static std::string const g_strNoColor = "no-color";
|
||||
static std::string const g_strErrorIds = "error-codes";
|
||||
|
||||
/// Possible arguments to for --machine
|
||||
static set<string> const g_machineArgs
|
||||
static std::set<std::string> const g_machineArgs
|
||||
{
|
||||
g_strEVM
|
||||
};
|
||||
|
||||
/// Possible arguments to for --yul-dialect
|
||||
static set<string> const g_yulDialectArgs
|
||||
static std::set<std::string> const g_yulDialectArgs
|
||||
{
|
||||
g_strEVM
|
||||
};
|
||||
|
||||
/// Possible arguments to for --metadata-hash
|
||||
static set<string> const g_metadataHashArgs
|
||||
static std::set<std::string> const g_metadataHashArgs
|
||||
{
|
||||
g_strIPFS,
|
||||
g_strSwarm,
|
||||
g_strNone
|
||||
};
|
||||
|
||||
static map<InputMode, string> const g_inputModeName = {
|
||||
static std::map<InputMode, std::string> const g_inputModeName = {
|
||||
{InputMode::Help, "help"},
|
||||
{InputMode::License, "license"},
|
||||
{InputMode::Version, "version"},
|
||||
@ -143,7 +142,7 @@ static map<InputMode, string> const g_inputModeName = {
|
||||
{InputMode::LanguageServer, "language server (LSP)"},
|
||||
};
|
||||
|
||||
void CommandLineParser::checkMutuallyExclusive(vector<string> const& _optionNames)
|
||||
void CommandLineParser::checkMutuallyExclusive(std::vector<std::string> const& _optionNames)
|
||||
{
|
||||
if (countEnabledOptions(_optionNames) > 1)
|
||||
{
|
||||
@ -163,9 +162,9 @@ bool CompilerOutputs::operator==(CompilerOutputs const& _other) const noexcept
|
||||
return true;
|
||||
}
|
||||
|
||||
ostream& operator<<(ostream& _out, CompilerOutputs const& _selection)
|
||||
std::ostream& operator<<(std::ostream& _out, CompilerOutputs const& _selection)
|
||||
{
|
||||
vector<string> serializedSelection;
|
||||
std::vector<std::string> serializedSelection;
|
||||
for (auto&& [componentName, component]: CompilerOutputs::componentMap())
|
||||
if (_selection.*component)
|
||||
serializedSelection.push_back(CompilerOutputs::componentName(component));
|
||||
@ -173,7 +172,7 @@ ostream& operator<<(ostream& _out, CompilerOutputs const& _selection)
|
||||
return _out << util::joinHumanReadable(serializedSelection, ",");
|
||||
}
|
||||
|
||||
string const& CompilerOutputs::componentName(bool CompilerOutputs::* _component)
|
||||
std::string const& CompilerOutputs::componentName(bool CompilerOutputs::* _component)
|
||||
{
|
||||
solAssert(_component, "");
|
||||
|
||||
@ -194,9 +193,9 @@ bool CombinedJsonRequests::operator==(CombinedJsonRequests const& _other) const
|
||||
}
|
||||
|
||||
|
||||
ostream& operator<<(ostream& _out, CombinedJsonRequests const& _requests)
|
||||
std::ostream& operator<<(std::ostream& _out, CombinedJsonRequests const& _requests)
|
||||
{
|
||||
vector<string> serializedRequests;
|
||||
std::vector<std::string> serializedRequests;
|
||||
for (auto&& [componentName, component]: CombinedJsonRequests::componentMap())
|
||||
if (_requests.*component)
|
||||
serializedRequests.push_back(CombinedJsonRequests::componentName(component));
|
||||
@ -204,7 +203,7 @@ ostream& operator<<(ostream& _out, CombinedJsonRequests const& _requests)
|
||||
return _out << util::joinHumanReadable(serializedRequests, ",");
|
||||
}
|
||||
|
||||
string const& CombinedJsonRequests::componentName(bool CombinedJsonRequests::* _component)
|
||||
std::string const& CombinedJsonRequests::componentName(bool CombinedJsonRequests::* _component)
|
||||
{
|
||||
solAssert(_component, "");
|
||||
|
||||
@ -274,11 +273,11 @@ OptimiserSettings CommandLineOptions::optimiserSettings() const
|
||||
|
||||
if (optimizer.yulSteps.has_value())
|
||||
{
|
||||
string const fullSequence = optimizer.yulSteps.value();
|
||||
std::string const fullSequence = optimizer.yulSteps.value();
|
||||
auto const delimiterPos = fullSequence.find(":");
|
||||
settings.yulOptimiserSteps = fullSequence.substr(0, delimiterPos);
|
||||
|
||||
if (delimiterPos != string::npos)
|
||||
if (delimiterPos != std::string::npos)
|
||||
settings.yulOptimiserCleanupSteps = fullSequence.substr(delimiterPos + 1);
|
||||
else
|
||||
solAssert(settings.yulOptimiserCleanupSteps == OptimiserSettings::DefaultYulOptimiserCleanupSteps);
|
||||
@ -298,11 +297,11 @@ void CommandLineParser::parseInputPathsAndRemappings()
|
||||
m_options.input.ignoreMissingFiles = (m_args.count(g_strIgnoreMissingFiles) > 0);
|
||||
|
||||
if (m_args.count(g_strInputFile))
|
||||
for (string const& positionalArg: m_args[g_strInputFile].as<vector<string>>())
|
||||
for (std::string const& positionalArg: m_args[g_strInputFile].as<std::vector<std::string>>())
|
||||
{
|
||||
if (ImportRemapper::isRemapping(positionalArg))
|
||||
{
|
||||
optional<ImportRemapper::Remapping> remapping = ImportRemapper::parseRemapping(positionalArg);
|
||||
std::optional<ImportRemapper::Remapping> remapping = ImportRemapper::parseRemapping(positionalArg);
|
||||
if (!remapping.has_value())
|
||||
solThrow(CommandLineValidationError, "Invalid remapping: \"" + positionalArg + "\".");
|
||||
|
||||
@ -353,10 +352,10 @@ void CommandLineParser::parseInputPathsAndRemappings()
|
||||
);
|
||||
}
|
||||
|
||||
void CommandLineParser::parseLibraryOption(string const& _input)
|
||||
void CommandLineParser::parseLibraryOption(std::string const& _input)
|
||||
{
|
||||
namespace fs = boost::filesystem;
|
||||
string data = _input;
|
||||
std::string data = _input;
|
||||
try
|
||||
{
|
||||
if (fs::is_regular_file(_input))
|
||||
@ -375,19 +374,19 @@ void CommandLineParser::parseLibraryOption(string const& _input)
|
||||
// Should not happen if `fs::is_regular_file` is correct.
|
||||
}
|
||||
|
||||
vector<string> libraries;
|
||||
std::vector<std::string> libraries;
|
||||
boost::split(libraries, data, boost::is_space() || boost::is_any_of(","), boost::token_compress_on);
|
||||
for (string const& lib: libraries)
|
||||
for (std::string const& lib: libraries)
|
||||
if (!lib.empty())
|
||||
{
|
||||
//search for equal sign or last colon in string as our binaries output placeholders in the form of file=Name or file:Name
|
||||
//so we need to search for `=` or `:` in the string
|
||||
auto separator = lib.rfind('=');
|
||||
bool isSeparatorEqualSign = true;
|
||||
if (separator == string::npos)
|
||||
if (separator == std::string::npos)
|
||||
{
|
||||
separator = lib.rfind(':');
|
||||
if (separator == string::npos)
|
||||
if (separator == std::string::npos)
|
||||
solThrow(
|
||||
CommandLineValidationError,
|
||||
"Equal sign separator missing in library address specifier \"" + lib + "\""
|
||||
@ -402,7 +401,7 @@ void CommandLineParser::parseLibraryOption(string const& _input)
|
||||
"Only one equal sign \"=\" is allowed in the address string \"" + lib + "\"."
|
||||
);
|
||||
|
||||
string libName(lib.begin(), lib.begin() + static_cast<ptrdiff_t>(separator));
|
||||
std::string libName(lib.begin(), lib.begin() + static_cast<ptrdiff_t>(separator));
|
||||
boost::trim(libName);
|
||||
if (m_options.linker.libraries.count(libName))
|
||||
solThrow(
|
||||
@ -410,7 +409,7 @@ void CommandLineParser::parseLibraryOption(string const& _input)
|
||||
"Address specified more than once for library \"" + libName + "\"."
|
||||
);
|
||||
|
||||
string addrString(lib.begin() + static_cast<ptrdiff_t>(separator) + 1, lib.end());
|
||||
std::string addrString(lib.begin() + static_cast<ptrdiff_t>(separator) + 1, lib.end());
|
||||
boost::trim(addrString);
|
||||
if (addrString.empty())
|
||||
solThrow(
|
||||
@ -433,7 +432,7 @@ void CommandLineParser::parseLibraryOption(string const& _input)
|
||||
solThrow(
|
||||
CommandLineValidationError,
|
||||
"Invalid length for address for library \"" + libName + "\": " +
|
||||
to_string(addrString.length()) + " instead of 40 characters."
|
||||
std::to_string(addrString.length()) + " instead of 40 characters."
|
||||
);
|
||||
if (!util::passesAddressChecksum(addrString, false))
|
||||
solThrow(
|
||||
@ -454,14 +453,14 @@ void CommandLineParser::parseLibraryOption(string const& _input)
|
||||
|
||||
void CommandLineParser::parseOutputSelection()
|
||||
{
|
||||
static auto outputSupported = [](InputMode _mode, string_view _outputName)
|
||||
static auto outputSupported = [](InputMode _mode, std::string_view _outputName)
|
||||
{
|
||||
static set<string> const compilerModeOutputs = (
|
||||
static std::set<std::string> const compilerModeOutputs = (
|
||||
CompilerOutputs::componentMap() |
|
||||
ranges::views::keys |
|
||||
ranges::to<set>()
|
||||
ranges::to<std::set>()
|
||||
);
|
||||
static set<string> const assemblerModeOutputs = {
|
||||
static std::set<std::string> const assemblerModeOutputs = {
|
||||
CompilerOutputs::componentName(&CompilerOutputs::asm_),
|
||||
CompilerOutputs::componentName(&CompilerOutputs::binary),
|
||||
CompilerOutputs::componentName(&CompilerOutputs::irOptimized),
|
||||
@ -500,7 +499,7 @@ void CommandLineParser::parseOutputSelection()
|
||||
m_options.compiler.outputs.irOptimized = true;
|
||||
}
|
||||
|
||||
vector<string> unsupportedOutputs;
|
||||
std::vector<std::string> unsupportedOutputs;
|
||||
for (auto&& [optionName, outputComponent]: CompilerOutputs::componentMap())
|
||||
if (m_options.compiler.outputs.*outputComponent && !outputSupported(m_options.input.mode, optionName))
|
||||
unsupportedOutputs.push_back(optionName);
|
||||
@ -547,12 +546,12 @@ General Information)").c_str(),
|
||||
inputOptions.add_options()
|
||||
(
|
||||
g_strBasePath.c_str(),
|
||||
po::value<string>()->value_name("path"),
|
||||
po::value<std::string>()->value_name("path"),
|
||||
"Use the given path as the root of the source tree instead of the root of the filesystem."
|
||||
)
|
||||
(
|
||||
g_strIncludePath.c_str(),
|
||||
po::value<vector<string>>()->value_name("path"),
|
||||
po::value<std::vector<std::string>>()->value_name("path"),
|
||||
"Make an additional source directory available to the default import callback. "
|
||||
"Use this option if you want to import contracts whose location is not fixed in relation "
|
||||
"to your main source tree, e.g. third-party libraries installed using a package manager. "
|
||||
@ -561,7 +560,7 @@ General Information)").c_str(),
|
||||
)
|
||||
(
|
||||
g_strAllowPaths.c_str(),
|
||||
po::value<string>()->value_name("path(s)"),
|
||||
po::value<std::string>()->value_name("path(s)"),
|
||||
"Allow a given path for imports. A list of paths can be supplied by separating them with a comma."
|
||||
)
|
||||
(
|
||||
@ -575,7 +574,7 @@ General Information)").c_str(),
|
||||
outputOptions.add_options()
|
||||
(
|
||||
(g_strOutputDir + ",o").c_str(),
|
||||
po::value<string>()->value_name("path"),
|
||||
po::value<std::string>()->value_name("path"),
|
||||
"If given, creates one file per output component and contract/file at the specified directory."
|
||||
)
|
||||
(
|
||||
@ -584,7 +583,7 @@ General Information)").c_str(),
|
||||
)
|
||||
(
|
||||
g_strEVMVersion.c_str(),
|
||||
po::value<string>()->value_name("version")->default_value(EVMVersion{}.name()),
|
||||
po::value<std::string>()->value_name("version")->default_value(EVMVersion{}.name()),
|
||||
"Select desired EVM version. Either homestead, tangerineWhistle, spuriousDragon, "
|
||||
"byzantium, constantinople, petersburg, istanbul, berlin, london, paris or shanghai."
|
||||
)
|
||||
@ -610,19 +609,19 @@ General Information)").c_str(),
|
||||
)
|
||||
(
|
||||
g_strRevertStrings.c_str(),
|
||||
po::value<string>()->value_name(util::joinHumanReadable(g_revertStringsArgs, ",")),
|
||||
po::value<std::string>()->value_name(util::joinHumanReadable(g_revertStringsArgs, ",")),
|
||||
"Strip revert (and require) reason strings or add additional debugging information."
|
||||
)
|
||||
(
|
||||
g_strDebugInfo.c_str(),
|
||||
po::value<string>()->default_value(util::toString(DebugInfoSelection::Default())),
|
||||
po::value<std::string>()->default_value(util::toString(DebugInfoSelection::Default())),
|
||||
("Debug info components to be included in the produced EVM assembly and Yul code. "
|
||||
"Value can be all, none or a comma-separated list containing one or more of the "
|
||||
"following components: " + util::joinHumanReadable(DebugInfoSelection::componentMap() | ranges::views::keys) + ".").c_str()
|
||||
)
|
||||
(
|
||||
g_strStopAfter.c_str(),
|
||||
po::value<string>()->value_name("stage"),
|
||||
po::value<std::string>()->value_name("stage"),
|
||||
"Stop execution after the given compiler stage. Valid options: \"parsing\"."
|
||||
)
|
||||
;
|
||||
@ -670,12 +669,12 @@ General Information)").c_str(),
|
||||
assemblyModeOptions.add_options()
|
||||
(
|
||||
g_strMachine.c_str(),
|
||||
po::value<string>()->value_name(util::joinHumanReadable(g_machineArgs, ",")),
|
||||
po::value<std::string>()->value_name(util::joinHumanReadable(g_machineArgs, ",")),
|
||||
"Target machine in assembly or Yul mode."
|
||||
)
|
||||
(
|
||||
g_strYulDialect.c_str(),
|
||||
po::value<string>()->value_name(util::joinHumanReadable(g_yulDialectArgs, ",")),
|
||||
po::value<std::string>()->value_name(util::joinHumanReadable(g_yulDialectArgs, ",")),
|
||||
"Input dialect to use in assembly or yul mode."
|
||||
)
|
||||
;
|
||||
@ -685,7 +684,7 @@ General Information)").c_str(),
|
||||
linkerModeOptions.add_options()
|
||||
(
|
||||
g_strLibraries.c_str(),
|
||||
po::value<vector<string>>()->value_name("libs"),
|
||||
po::value<std::vector<std::string>>()->value_name("libs"),
|
||||
"Direct string or file containing library addresses. Syntax: "
|
||||
"<libraryName>=<address> [, or whitespace] ...\n"
|
||||
"Address is interpreted as a hex string prefixed by 0x."
|
||||
@ -748,7 +747,7 @@ General Information)").c_str(),
|
||||
)
|
||||
(
|
||||
g_strCombinedJson.c_str(),
|
||||
po::value<string>()->value_name(util::joinHumanReadable(CombinedJsonRequests::componentMap() | ranges::views::keys, ",")),
|
||||
po::value<std::string>()->value_name(util::joinHumanReadable(CombinedJsonRequests::componentMap() | ranges::views::keys, ",")),
|
||||
"Output a single json document containing the specified information."
|
||||
)
|
||||
;
|
||||
@ -762,7 +761,7 @@ General Information)").c_str(),
|
||||
)
|
||||
(
|
||||
g_strMetadataHash.c_str(),
|
||||
po::value<string>()->value_name(util::joinHumanReadable(g_metadataHashArgs, ",")),
|
||||
po::value<std::string>()->value_name(util::joinHumanReadable(g_metadataHashArgs, ",")),
|
||||
"Choose hash method for the bytecode metadata or disable it."
|
||||
)
|
||||
(
|
||||
@ -798,7 +797,7 @@ General Information)").c_str(),
|
||||
)
|
||||
(
|
||||
g_strYulOptimizations.c_str(),
|
||||
po::value<string>()->value_name("steps"),
|
||||
po::value<std::string>()->value_name("steps"),
|
||||
"Forces Yul optimizer to use the specified sequence of optimization steps instead of the built-in one."
|
||||
)
|
||||
;
|
||||
@ -808,7 +807,7 @@ General Information)").c_str(),
|
||||
smtCheckerOptions.add_options()
|
||||
(
|
||||
g_strModelCheckerContracts.c_str(),
|
||||
po::value<string>()->value_name("default,<source>:<contract>")->default_value("default"),
|
||||
po::value<std::string>()->value_name("default,<source>:<contract>")->default_value("default"),
|
||||
"Select which contracts should be analyzed using the form <source>:<contract>."
|
||||
"Multiple pairs <source>:<contract> can be selected at the same time, separated by a comma "
|
||||
"and no spaces."
|
||||
@ -820,18 +819,18 @@ General Information)").c_str(),
|
||||
)
|
||||
(
|
||||
g_strModelCheckerEngine.c_str(),
|
||||
po::value<string>()->value_name("all,bmc,chc,none")->default_value("none"),
|
||||
po::value<std::string>()->value_name("all,bmc,chc,none")->default_value("none"),
|
||||
"Select model checker engine."
|
||||
)
|
||||
(
|
||||
g_strModelCheckerExtCalls.c_str(),
|
||||
po::value<string>()->value_name("untrusted,trusted")->default_value("untrusted"),
|
||||
po::value<std::string>()->value_name("untrusted,trusted")->default_value("untrusted"),
|
||||
"Select whether to assume (trusted) that external calls always invoke"
|
||||
" the code given by the type of the contract, if that code is available."
|
||||
)
|
||||
(
|
||||
g_strModelCheckerInvariants.c_str(),
|
||||
po::value<string>()->value_name("default,all,contract,reentrancy")->default_value("default"),
|
||||
po::value<std::string>()->value_name("default,all,contract,reentrancy")->default_value("default"),
|
||||
"Select whether to report inferred contract inductive invariants."
|
||||
" Multiple types of invariants can be selected at the same time, separated by a comma and no spaces."
|
||||
" By default no invariants are reported."
|
||||
@ -854,12 +853,12 @@ General Information)").c_str(),
|
||||
)
|
||||
(
|
||||
g_strModelCheckerSolvers.c_str(),
|
||||
po::value<string>()->value_name("cvc4,eld,z3,smtlib2")->default_value("z3"),
|
||||
po::value<std::string>()->value_name("cvc4,eld,z3,smtlib2")->default_value("z3"),
|
||||
"Select model checker solvers."
|
||||
)
|
||||
(
|
||||
g_strModelCheckerTargets.c_str(),
|
||||
po::value<string>()->value_name("default,all,constantCondition,underflow,overflow,divByZero,balance,assert,popEmptyArray,outOfBounds")->default_value("default"),
|
||||
po::value<std::string>()->value_name("default,all,constantCondition,underflow,overflow,divByZero,balance,assert,popEmptyArray,outOfBounds")->default_value("default"),
|
||||
"Select model checker verification targets."
|
||||
"Multiple targets can be selected at the same time, separated by a comma and no spaces."
|
||||
" By default all targets except underflow and overflow are selected."
|
||||
@ -880,7 +879,7 @@ General Information)").c_str(),
|
||||
;
|
||||
desc.add(smtCheckerOptions);
|
||||
|
||||
desc.add_options()(g_strInputFile.c_str(), po::value<vector<string>>(), "input file");
|
||||
desc.add_options()(g_strInputFile.c_str(), po::value<std::vector<std::string>>(), "input file");
|
||||
return desc;
|
||||
}
|
||||
|
||||
@ -954,7 +953,7 @@ void CommandLineParser::processArgs()
|
||||
)
|
||||
return;
|
||||
|
||||
map<string, set<InputMode>> validOptionInputModeCombinations = {
|
||||
std::map<std::string, std::set<InputMode>> validOptionInputModeCombinations = {
|
||||
// TODO: This should eventually contain all options.
|
||||
{g_strExperimentalViaIR, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
|
||||
{g_strViaIR, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
|
||||
@ -975,7 +974,7 @@ void CommandLineParser::processArgs()
|
||||
{g_strModelCheckerContracts, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
|
||||
{g_strModelCheckerTargets, {InputMode::Compiler, InputMode::CompilerWithASTImport}}
|
||||
};
|
||||
vector<string> invalidOptionsForCurrentInputMode;
|
||||
std::vector<std::string> invalidOptionsForCurrentInputMode;
|
||||
for (auto const& [optionName, inputModes]: validOptionInputModeCombinations)
|
||||
{
|
||||
if (
|
||||
@ -999,7 +998,7 @@ void CommandLineParser::processArgs()
|
||||
checkMutuallyExclusive({g_strColor, g_strNoColor});
|
||||
checkMutuallyExclusive({g_strStopAfter, g_strGas});
|
||||
|
||||
for (string const& option: CompilerOutputs::componentMap() | ranges::views::keys)
|
||||
for (std::string const& option: CompilerOutputs::componentMap() | ranges::views::keys)
|
||||
if (option != CompilerOutputs::componentName(&CompilerOutputs::astCompactJson))
|
||||
checkMutuallyExclusive({g_strStopAfter, option});
|
||||
|
||||
@ -1015,7 +1014,7 @@ void CommandLineParser::processArgs()
|
||||
"Option --" + g_strOptimizeRuns + " is only valid in compiler and assembler modes."
|
||||
);
|
||||
|
||||
for (string const& option: {g_strOptimize, g_strNoOptimizeYul, g_strOptimizeYul, g_strYulOptimizations})
|
||||
for (std::string const& option: {g_strOptimize, g_strNoOptimizeYul, g_strOptimizeYul, g_strYulOptimizations})
|
||||
if (m_args.count(option) > 0)
|
||||
solThrow(
|
||||
CommandLineValidationError,
|
||||
@ -1038,8 +1037,8 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strRevertStrings))
|
||||
{
|
||||
string revertStringsString = m_args[g_strRevertStrings].as<string>();
|
||||
optional<RevertStrings> revertStrings = revertStringsFromString(revertStringsString);
|
||||
std::string revertStringsString = m_args[g_strRevertStrings].as<std::string>();
|
||||
std::optional<RevertStrings> revertStrings = revertStringsFromString(revertStringsString);
|
||||
if (!revertStrings)
|
||||
solThrow(
|
||||
CommandLineValidationError,
|
||||
@ -1055,7 +1054,7 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (!m_args[g_strDebugInfo].defaulted())
|
||||
{
|
||||
string optionValue = m_args[g_strDebugInfo].as<string>();
|
||||
std::string optionValue = m_args[g_strDebugInfo].as<std::string>();
|
||||
m_options.output.debugInfoSelection = DebugInfoSelection::fromString(optionValue);
|
||||
if (!m_options.output.debugInfoSelection.has_value())
|
||||
solThrow(CommandLineValidationError, "Invalid value for --" + g_strDebugInfo + " option: " + optionValue);
|
||||
@ -1067,7 +1066,7 @@ void CommandLineParser::processArgs()
|
||||
parseCombinedJsonOption();
|
||||
|
||||
if (m_args.count(g_strOutputDir))
|
||||
m_options.output.dir = m_args.at(g_strOutputDir).as<string>();
|
||||
m_options.output.dir = m_args.at(g_strOutputDir).as<std::string>();
|
||||
|
||||
m_options.output.overwriteFiles = (m_args.count(g_strOverwrite) > 0);
|
||||
|
||||
@ -1086,14 +1085,14 @@ void CommandLineParser::processArgs()
|
||||
m_options.compiler.estimateGas = (m_args.count(g_strGas) > 0);
|
||||
|
||||
if (m_args.count(g_strBasePath))
|
||||
m_options.input.basePath = m_args[g_strBasePath].as<string>();
|
||||
m_options.input.basePath = m_args[g_strBasePath].as<std::string>();
|
||||
|
||||
if (m_args.count(g_strIncludePath) > 0)
|
||||
{
|
||||
if (m_options.input.basePath.empty())
|
||||
solThrow(CommandLineValidationError, "--" + g_strIncludePath + " option requires a non-empty base path.");
|
||||
|
||||
for (string const& includePath: m_args[g_strIncludePath].as<vector<string>>())
|
||||
for (std::string const& includePath: m_args[g_strIncludePath].as<std::vector<std::string>>())
|
||||
{
|
||||
if (includePath.empty())
|
||||
solThrow(CommandLineValidationError, "Empty values are not allowed in --" + g_strIncludePath + ".");
|
||||
@ -1104,15 +1103,15 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strAllowPaths))
|
||||
{
|
||||
vector<string> paths;
|
||||
for (string const& allowedPath: boost::split(paths, m_args[g_strAllowPaths].as<string>(), boost::is_any_of(",")))
|
||||
std::vector<std::string> paths;
|
||||
for (std::string const& allowedPath: boost::split(paths, m_args[g_strAllowPaths].as<std::string>(), boost::is_any_of(",")))
|
||||
if (!allowedPath.empty())
|
||||
m_options.input.allowedDirectories.insert(allowedPath);
|
||||
}
|
||||
|
||||
if (m_args.count(g_strStopAfter))
|
||||
{
|
||||
if (m_args[g_strStopAfter].as<string>() != "parsing")
|
||||
if (m_args[g_strStopAfter].as<std::string>() != "parsing")
|
||||
solThrow(CommandLineValidationError, "Valid options for --" + g_strStopAfter + " are: \"parsing\".\n");
|
||||
else
|
||||
m_options.output.stopAfter = CompilerStack::State::Parsed;
|
||||
@ -1124,7 +1123,7 @@ void CommandLineParser::processArgs()
|
||||
return;
|
||||
|
||||
if (m_args.count(g_strLibraries))
|
||||
for (string const& library: m_args[g_strLibraries].as<vector<string>>())
|
||||
for (std::string const& library: m_args[g_strLibraries].as<std::vector<std::string>>())
|
||||
parseLibraryOption(library);
|
||||
|
||||
if (m_options.input.mode == InputMode::Linker)
|
||||
@ -1132,8 +1131,8 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strEVMVersion))
|
||||
{
|
||||
string versionOptionStr = m_args[g_strEVMVersion].as<string>();
|
||||
optional<langutil::EVMVersion> versionOption = langutil::EVMVersion::fromString(versionOptionStr);
|
||||
std::string versionOptionStr = m_args[g_strEVMVersion].as<std::string>();
|
||||
std::optional<langutil::EVMVersion> versionOption = langutil::EVMVersion::fromString(versionOptionStr);
|
||||
if (!versionOption)
|
||||
solThrow(CommandLineValidationError, "Invalid option for --" + g_strEVMVersion + ": " + versionOptionStr);
|
||||
m_options.output.evmVersion = *versionOption;
|
||||
@ -1144,7 +1143,7 @@ void CommandLineParser::processArgs()
|
||||
// Request as uint64_t, since uint8_t will be parsed as character by boost.
|
||||
uint64_t versionOption = m_args[g_strEOFVersion].as<uint64_t>();
|
||||
if (versionOption != 1)
|
||||
solThrow(CommandLineValidationError, "Invalid option for --" + g_strEOFVersion + ": " + to_string(versionOption));
|
||||
solThrow(CommandLineValidationError, "Invalid option for --" + g_strEOFVersion + ": " + std::to_string(versionOption));
|
||||
m_options.output.eofVersion = 1;
|
||||
}
|
||||
|
||||
@ -1170,7 +1169,7 @@ void CommandLineParser::processArgs()
|
||||
|
||||
try
|
||||
{
|
||||
yul::OptimiserSuite::validateSequence(m_args[g_strYulOptimizations].as<string>());
|
||||
yul::OptimiserSuite::validateSequence(m_args[g_strYulOptimizations].as<std::string>());
|
||||
}
|
||||
catch (yul::OptimizerException const& _exception)
|
||||
{
|
||||
@ -1180,12 +1179,12 @@ void CommandLineParser::processArgs()
|
||||
);
|
||||
}
|
||||
|
||||
m_options.optimizer.yulSteps = m_args[g_strYulOptimizations].as<string>();
|
||||
m_options.optimizer.yulSteps = m_args[g_strYulOptimizations].as<std::string>();
|
||||
}
|
||||
|
||||
if (m_options.input.mode == InputMode::Assembler)
|
||||
{
|
||||
vector<string> const nonAssemblyModeOptions = {
|
||||
std::vector<std::string> const nonAssemblyModeOptions = {
|
||||
// TODO: The list is not complete. Add more.
|
||||
g_strOutputDir,
|
||||
g_strGas,
|
||||
@ -1193,10 +1192,10 @@ void CommandLineParser::processArgs()
|
||||
};
|
||||
if (countEnabledOptions(nonAssemblyModeOptions) >= 1)
|
||||
{
|
||||
auto optionEnabled = [&](string const& name){ return m_args.count(name) > 0; };
|
||||
auto optionEnabled = [&](std::string const& name){ return m_args.count(name) > 0; };
|
||||
auto enabledOptions = nonAssemblyModeOptions | ranges::views::filter(optionEnabled) | ranges::to_vector;
|
||||
|
||||
string message = "The following options are invalid in assembly mode: " + joinOptionNames(enabledOptions) + ".";
|
||||
std::string message = "The following options are invalid in assembly mode: " + joinOptionNames(enabledOptions) + ".";
|
||||
solThrow(CommandLineValidationError, message);
|
||||
}
|
||||
|
||||
@ -1207,7 +1206,7 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strMachine))
|
||||
{
|
||||
string machine = m_args[g_strMachine].as<string>();
|
||||
std::string machine = m_args[g_strMachine].as<std::string>();
|
||||
if (machine == g_strEVM)
|
||||
m_options.assembly.targetMachine = Machine::EVM;
|
||||
else
|
||||
@ -1215,7 +1214,7 @@ void CommandLineParser::processArgs()
|
||||
}
|
||||
if (m_args.count(g_strYulDialect))
|
||||
{
|
||||
string dialect = m_args[g_strYulDialect].as<string>();
|
||||
std::string dialect = m_args[g_strYulDialect].as<std::string>();
|
||||
if (dialect == g_strEVM)
|
||||
m_options.assembly.inputLanguage = Input::StrictAssembly;
|
||||
else
|
||||
@ -1239,7 +1238,7 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strMetadataHash))
|
||||
{
|
||||
string hashStr = m_args[g_strMetadataHash].as<string>();
|
||||
std::string hashStr = m_args[g_strMetadataHash].as<std::string>();
|
||||
if (hashStr == g_strIPFS)
|
||||
m_options.metadata.hash = CompilerStack::MetadataHash::IPFS;
|
||||
else if (hashStr == g_strSwarm)
|
||||
@ -1267,8 +1266,8 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strModelCheckerContracts))
|
||||
{
|
||||
string contractsStr = m_args[g_strModelCheckerContracts].as<string>();
|
||||
optional<ModelCheckerContracts> contracts = ModelCheckerContracts::fromString(contractsStr);
|
||||
std::string contractsStr = m_args[g_strModelCheckerContracts].as<std::string>();
|
||||
std::optional<ModelCheckerContracts> contracts = ModelCheckerContracts::fromString(contractsStr);
|
||||
if (!contracts)
|
||||
solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerContracts + ": " + contractsStr);
|
||||
m_options.modelChecker.settings.contracts = std::move(*contracts);
|
||||
@ -1279,8 +1278,8 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strModelCheckerEngine))
|
||||
{
|
||||
string engineStr = m_args[g_strModelCheckerEngine].as<string>();
|
||||
optional<ModelCheckerEngine> engine = ModelCheckerEngine::fromString(engineStr);
|
||||
std::string engineStr = m_args[g_strModelCheckerEngine].as<std::string>();
|
||||
std::optional<ModelCheckerEngine> engine = ModelCheckerEngine::fromString(engineStr);
|
||||
if (!engine)
|
||||
solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerEngine + ": " + engineStr);
|
||||
m_options.modelChecker.settings.engine = *engine;
|
||||
@ -1288,8 +1287,8 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strModelCheckerExtCalls))
|
||||
{
|
||||
string mode = m_args[g_strModelCheckerExtCalls].as<string>();
|
||||
optional<ModelCheckerExtCalls> extCallsMode = ModelCheckerExtCalls::fromString(mode);
|
||||
std::string mode = m_args[g_strModelCheckerExtCalls].as<std::string>();
|
||||
std::optional<ModelCheckerExtCalls> extCallsMode = ModelCheckerExtCalls::fromString(mode);
|
||||
if (!extCallsMode)
|
||||
solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerExtCalls + ": " + mode);
|
||||
m_options.modelChecker.settings.externalCalls = *extCallsMode;
|
||||
@ -1297,8 +1296,8 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strModelCheckerInvariants))
|
||||
{
|
||||
string invsStr = m_args[g_strModelCheckerInvariants].as<string>();
|
||||
optional<ModelCheckerInvariants> invs = ModelCheckerInvariants::fromString(invsStr);
|
||||
std::string invsStr = m_args[g_strModelCheckerInvariants].as<std::string>();
|
||||
std::optional<ModelCheckerInvariants> invs = ModelCheckerInvariants::fromString(invsStr);
|
||||
if (!invs)
|
||||
solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerInvariants + ": " + invsStr);
|
||||
m_options.modelChecker.settings.invariants = *invs;
|
||||
@ -1315,8 +1314,8 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strModelCheckerSolvers))
|
||||
{
|
||||
string solversStr = m_args[g_strModelCheckerSolvers].as<string>();
|
||||
optional<smtutil::SMTSolverChoice> solvers = smtutil::SMTSolverChoice::fromString(solversStr);
|
||||
std::string solversStr = m_args[g_strModelCheckerSolvers].as<std::string>();
|
||||
std::optional<smtutil::SMTSolverChoice> solvers = smtutil::SMTSolverChoice::fromString(solversStr);
|
||||
if (!solvers)
|
||||
solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerSolvers + ": " + solversStr);
|
||||
m_options.modelChecker.settings.solvers = *solvers;
|
||||
@ -1331,8 +1330,8 @@ void CommandLineParser::processArgs()
|
||||
|
||||
if (m_args.count(g_strModelCheckerTargets))
|
||||
{
|
||||
string targetsStr = m_args[g_strModelCheckerTargets].as<string>();
|
||||
optional<ModelCheckerTargets> targets = ModelCheckerTargets::fromString(targetsStr);
|
||||
std::string targetsStr = m_args[g_strModelCheckerTargets].as<std::string>();
|
||||
std::optional<ModelCheckerTargets> targets = ModelCheckerTargets::fromString(targetsStr);
|
||||
if (!targets)
|
||||
solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerTargets + ": " + targetsStr);
|
||||
m_options.modelChecker.settings.targets = *targets;
|
||||
@ -1371,8 +1370,8 @@ void CommandLineParser::parseCombinedJsonOption()
|
||||
if (!m_args.count(g_strCombinedJson))
|
||||
return;
|
||||
|
||||
set<string> requests;
|
||||
for (string const& item: boost::split(requests, m_args[g_strCombinedJson].as<string>(), boost::is_any_of(",")))
|
||||
std::set<std::string> requests;
|
||||
for (std::string const& item: boost::split(requests, m_args[g_strCombinedJson].as<std::string>(), boost::is_any_of(",")))
|
||||
if (CombinedJsonRequests::componentMap().count(item) == 0)
|
||||
solThrow(CommandLineValidationError, "Invalid option to --" + g_strCombinedJson + ": " + item);
|
||||
|
||||
@ -1381,19 +1380,19 @@ void CommandLineParser::parseCombinedJsonOption()
|
||||
m_options.compiler.combinedJsonRequests.value().*component = (requests.count(componentName) > 0);
|
||||
}
|
||||
|
||||
size_t CommandLineParser::countEnabledOptions(vector<string> const& _optionNames) const
|
||||
size_t CommandLineParser::countEnabledOptions(std::vector<std::string> const& _optionNames) const
|
||||
{
|
||||
size_t count = 0;
|
||||
for (string const& _option: _optionNames)
|
||||
for (std::string const& _option: _optionNames)
|
||||
count += m_args.count(_option);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
string CommandLineParser::joinOptionNames(vector<string> const& _optionNames, string _separator)
|
||||
std::string CommandLineParser::joinOptionNames(std::vector<std::string> const& _optionNames, std::string _separator)
|
||||
{
|
||||
return util::joinHumanReadable(
|
||||
_optionNames | ranges::views::transform([](string const& _option){ return "--" + _option; }),
|
||||
_optionNames | ranges::views::transform([](std::string const& _option){ return "--" + _option; }),
|
||||
_separator
|
||||
);
|
||||
}
|
||||
|
||||
@ -29,7 +29,6 @@
|
||||
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
using namespace solidity;
|
||||
|
||||
|
||||
@ -37,31 +36,31 @@ int main(int argc, char** argv)
|
||||
{
|
||||
try
|
||||
{
|
||||
solidity::frontend::CommandLineInterface cli(cin, cout, cerr);
|
||||
solidity::frontend::CommandLineInterface cli(std::cin, std::cout, std::cerr);
|
||||
return cli.run(argc, argv) ? 0 : 1;
|
||||
}
|
||||
catch (smtutil::SMTLogicError const& _exception)
|
||||
{
|
||||
cerr << "SMT logic error:" << endl;
|
||||
cerr << boost::diagnostic_information(_exception);
|
||||
std::cerr << "SMT logic error:" << std::endl;
|
||||
std::cerr << boost::diagnostic_information(_exception);
|
||||
return 2;
|
||||
}
|
||||
catch (langutil::UnimplementedFeatureError const& _exception)
|
||||
{
|
||||
cerr << "Unimplemented feature:" << endl;
|
||||
cerr << boost::diagnostic_information(_exception);
|
||||
std::cerr << "Unimplemented feature:" << std::endl;
|
||||
std::cerr << boost::diagnostic_information(_exception);
|
||||
return 2;
|
||||
}
|
||||
catch (langutil::InternalCompilerError const& _exception)
|
||||
{
|
||||
cerr << "Internal compiler error:" << endl;
|
||||
cerr << boost::diagnostic_information(_exception);
|
||||
std::cerr << "Internal compiler error:" << std::endl;
|
||||
std::cerr << boost::diagnostic_information(_exception);
|
||||
return 2;
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
cerr << "Uncaught exception:" << endl;
|
||||
cerr << boost::current_exception_diagnostic_information() << endl;
|
||||
std::cerr << "Uncaught exception:" << std::endl;
|
||||
std::cerr << boost::current_exception_diagnostic_information() << std::endl;
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user