{

void printErrors()

{

SourceReferenceFormatter formatter(cerr, true, false);

for (auto const& error: m_errors)

formatter.printErrorInformation(*error);

}

bool parse(string const& _input)

{

ErrorReporter errorReporter(m_errors);

shared_ptr<Scanner> scanner = make_shared<Scanner>(CharStream(_input, ""));

m_ast = yul::Parser(errorReporter, m_dialect).parse(scanner, false);

if (!m_ast || !errorReporter.errors().empty())

{

cerr << "Error parsing source." << endl;

printErrors();

return false;

}

m_analysisInfo = make_shared<yul::AsmAnalysisInfo>();

AsmAnalyzer analyzer(

*m_analysisInfo,

errorReporter,

m_dialect

);

if (!analyzer.analyze(*m_ast) || !errorReporter.errors().empty())

{

cerr << "Error analyzing source." << endl;

printErrors();

return false;

}

return true;

}

void printUsageBanner(

map<char, string> const& _optimizationSteps,

map<char, string> const& _extraOptions,

size_t _columns

)

{

yulAssert(_columns > 0, "");

auto hasShorterString = [](auto const& a, auto const& b) { return a.second.size() < b.second.size(); };

size_t longestDescriptionLength = std::max(

max_element(_optimizationSteps.begin(), _optimizationSteps.end(), hasShorterString)->second.size(),

max_element(_extraOptions.begin(), _extraOptions.end(), hasShorterString)->second.size()

);

vector<string> overlappingAbbreviations =

ranges::views::set_intersection(_extraOptions | ranges::views::keys, _optimizationSteps | ranges::views::keys) |

ranges::views::transform([](char _abbreviation){ return string(1, _abbreviation); }) |

ranges::to<vector>();

yulAssert(

overlappingAbbreviations.empty(),

"ERROR: Conflict between yulopti controls and the following Yul optimizer step abbreviations: " +

boost::join(overlappingAbbreviations, ", ") + ".\n"

"This is most likely caused by someone adding a new step abbreviation to "

"OptimiserSuite::stepNameToAbbreviationMap() and not realizing that it's used by yulopti.\n"

"Please update the code to use a different character and recompile yulopti."

);

vector<tuple<char, string>> sortedOptions =

ranges::views::concat(_optimizationSteps, _extraOptions) |

ranges::to<vector<tuple<char, string>>>() |

ranges::actions::sort([](tuple<char, string> const& _a, tuple<char, string> const& _b) {

return (

!boost::algorithm::iequals(get<1>(_a), get<1>(_b)) ?

boost::algorithm::lexicographical_compare(get<1>(_a), get<1>(_b), boost::algorithm::is_iless()) :

tolower(get<0>(_a)) < tolower(get<0>(_b))

);

});

yulAssert(sortedOptions.size() > 0, "");

size_t rows = (sortedOptions.size() - 1) / _columns + 1;

for (size_t row = 0; row < rows; ++row)

{

for (auto const& [key, name]: sortedOptions | ranges::views::drop(row) | ranges::views::stride(rows))

cout << key << ": " << setw(static_cast<int>(longestDescriptionLength)) << setiosflags(ios::left) << name << " ";

cout << endl;

}

}

void runInteractive(string source)

{

bool disambiguated = false;

while (true)

{

cout << "----------------------" << endl;

cout << source << endl;

if (!parse(source))

return;

set<YulString> reservedIdentifiers;

if (!disambiguated)

{

*m_ast = std::get<yul::Block>(Disambiguator(m_dialect, *m_analysisInfo)(*m_ast));

m_analysisInfo.reset();

m_nameDispenser = make_shared<NameDispenser>(m_dialect, *m_ast, reservedIdentifiers);

disambiguated = true;

}

map<char, string> const& abbreviationMap = OptimiserSuite::stepAbbreviationToNameMap();

map<char, string> const& extraOptions = {

// QUIT starts with a non-letter character on purpose to get it to show up on top of the list

{'#', ">>> QUIT <<<"},

{',', "VarNameCleaner"},

{';', "StackCompressor"}

};

printUsageBanner(abbreviationMap, extraOptions, 4);

cout << "? ";

cout.flush();

// TODO: handle EOF properly.

char option = static_cast<char>(readStandardInputChar());

cout << ' ' << option << endl;

OptimiserStepContext context{

m_dialect,

*m_nameDispenser,

reservedIdentifiers,

solidity::frontend::OptimiserSettings::standard().expectedExecutionsPerDeployment

};

auto abbreviationAndName = abbreviationMap.find(option);

if (abbreviationAndName != abbreviationMap.end())

{

OptimiserStep const& step = *OptimiserSuite::allSteps().at(abbreviationAndName->second);

step.run(context, *m_ast);

}

else switch (option)

{

case '#':

return;

case ',':

VarNameCleaner::run(context, *m_ast);

// VarNameCleaner destroys the unique names guarantee of the disambiguator.

disambiguated = false;

break;

case ';':

{

Object obj;

obj.code = m_ast;

StackCompressor::run(m_dialect, obj, true, 16);

break;

}

default:

cerr << "Unknown option." << endl;

}

source = AsmPrinter{m_dialect}(*m_ast);

}

}

ErrorList m_errors;

shared_ptr<yul::Block> m_ast;

Dialect const& m_dialect{EVMDialect::strictAssemblyForEVMObjects(EVMVersion{})};

shared_ptr<AsmAnalysisInfo> m_analysisInfo;

shared_ptr<NameDispenser> m_nameDispenser;

{

po::options_description options(

R"(yulopti, yul optimizer exploration tool.

Allowed options)",

po::options_description::m_default_line_length,

po::options_description::m_default_line_length - 23);

options.add_options()

(

"input-file",

po::value<string>(),

"input file"

)

("help", "Show this help screen.");

// All positional options should be interpreted as input files

po::positional_options_description filesPositions;

filesPositions.add("input-file", 1);

po::variables_map arguments;

try

{

po::command_line_parser cmdLineParser(argc, argv);

cmdLineParser.options(options).positional(filesPositions);

po::store(cmdLineParser.run(), arguments);

}

catch (po::error const& _exception)

{

cerr << _exception.what() << endl;

return 1;

}

string input;

try

{

input = readFileAsString(arguments["input-file"].as<string>());

}

catch (FileNotFound const& _exception)

{

cerr << "File not found:" << _exception.comment() << endl;

return 1;

}

if (arguments.count("input-file"))

YulOpti{}.runInteractive(input);

else

cout << options;

return 0;