size_t lastdot = filename.find_last_of(".");

if (lastdot == std::string::npos) return filename;

return filename.substr(0, lastdot);

size_t lastslash = filename.find_last_of("/");

if (lastslash == std::string::npos) return filename;

return filename.substr(lastslash+1);

{

char *env_p = std::getenv("LFORTRAN_KOKKOS_DIR");

if (env_p) return env_p;

std::cerr << "The code C++ generated by the C++ LFortran backend uses the Kokkos library" << std::endl;

std::cerr << "(https://github.com/kokkos/kokkos). Please define the LFORTRAN_KOKKOS_DIR" << std::endl;

std::cerr << "environment variable to point to the Kokkos installation." << std::endl;

throw LFortran::LCompilersException("LFORTRAN_KOKKOS_DIR is not defined");

{

std::string input = LFortran::read_file(infile);

// Src -> Tokens

Allocator al(64*1024*1024);

std::vector<int> toks;

std::vector<LFortran::YYSTYPE> stypes;

std::vector<LFortran::Location> locations;

LFortran::diag::Diagnostics diagnostics;

auto res = LFortran::tokens(al, input, diagnostics, &stypes, &locations);

LFortran::LocationManager lm;

lm.in_filename = infile;

lm.init_simple(input);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (res.ok) {

toks = res.result;

} else {

LFORTRAN_ASSERT(diagnostics.has_error())

return 1;

}

for (size_t i=0; i < toks.size(); i++) {

std::cout << LFortran::pickle_token(toks[i], stypes[i]);

if (line_numbers) {

std::cout << " " << locations[i].first << ":" << locations[i].last;

}

std::cout << std::endl;

}

return 0;

const std::string &runtime_library_dir,

CompilerOptions &compiler_options)

{

Allocator al(4*1024);

LFortran::diag::Diagnostics diagnostics;

LFortran::Result<LFortran::LPython::AST::ast_t*> r = parse_python_file(

al, runtime_library_dir, infile, diagnostics, compiler_options.new_parser);

if (diagnostics.diagnostics.size() > 0) {

LFortran::LocationManager lm;

lm.in_filename = infile;

// TODO: only read this once, and pass it as an argument to parse_python_file()

std::string input = LFortran::read_file(infile);

lm.init_simple(input);

std::cerr << diagnostics.render(input, lm, compiler_options);

}

if (!r.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

return 1;

}

LFortran::LPython::AST::ast_t* ast = r.result;

if (compiler_options.tree) {

std::cout << LFortran::LPython::pickle_tree_python(*ast,

compiler_options.use_colors) << std::endl;

} else {

std::cout << LFortran::LPython::pickle_python(*ast,

compiler_options.use_colors, compiler_options.indent) << std::endl;

}

return 0;

LCompilers::PassManager& pass_manager,

const std::string &runtime_library_dir,

bool with_intrinsic_modules, CompilerOptions &compiler_options)

{

Allocator al(4*1024);

LFortran::diag::Diagnostics diagnostics;

LFortran::LocationManager lm;

lm.in_filename = infile;

std::string input = LFortran::read_file(infile);

lm.init_simple(input);

LFortran::Result<LFortran::LPython::AST::ast_t*> r1 = parse_python_file(

al, runtime_library_dir, infile, diagnostics, compiler_options.new_parser);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r1.ok) {

return 1;

}

LFortran::LPython::AST::ast_t* ast = r1.result;

diagnostics.diagnostics.clear();

LFortran::Result<LFortran::ASR::TranslationUnit_t*>

r = LFortran::LPython::python_ast_to_asr(al, *ast, diagnostics, true,

compiler_options.disable_main, compiler_options.symtab_only, infile);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

return 2;

}

LFortran::ASR::TranslationUnit_t* asr = r.result;

LCompilers::PassOptions pass_options;

pass_options.run_fun = "f";

pass_options.always_run = true;

pass_manager.apply_passes(al, asr, pass_options);

if (compiler_options.tree) {

std::cout << LFortran::pickle_tree(*asr, compiler_options.use_colors,

with_intrinsic_modules) << std::endl;

} else {

std::cout << LFortran::pickle(*asr, compiler_options.use_colors, compiler_options.indent,

with_intrinsic_modules) << std::endl;

}

return 0;

const std::string &runtime_library_dir,

CompilerOptions &compiler_options)

{

Allocator al(4*1024);

LFortran::diag::Diagnostics diagnostics;

LFortran::LocationManager lm;

lm.in_filename = infile;

std::string input = LFortran::read_file(infile);

lm.init_simple(input);

LFortran::Result<LFortran::LPython::AST::ast_t*> r = parse_python_file(

al, runtime_library_dir, infile, diagnostics, compiler_options.new_parser);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r.ok) {

return 1;

}

LFortran::LPython::AST::ast_t* ast = r.result;

diagnostics.diagnostics.clear();

LFortran::Result<LFortran::ASR::TranslationUnit_t*>

r1 = LFortran::LPython::python_ast_to_asr(al, *ast, diagnostics, true,

compiler_options.disable_main, compiler_options.symtab_only, infile);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r1.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

return 2;

}

LFortran::ASR::TranslationUnit_t* asr = r1.result;

diagnostics.diagnostics.clear();

auto res = LFortran::asr_to_cpp(al, *asr, diagnostics,

compiler_options.platform, 0);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!res.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

return 3;

}

std::cout << res.result;

return 0;

const std::string &runtime_library_dir,

CompilerOptions &compiler_options)

{

Allocator al(4*1024);

LFortran::diag::Diagnostics diagnostics;

LFortran::LocationManager lm;

lm.in_filename = infile;

std::string input = LFortran::read_file(infile);

lm.init_simple(input);

LFortran::Result<LFortran::LPython::AST::ast_t*> r = parse_python_file(

al, runtime_library_dir, infile, diagnostics, compiler_options.new_parser);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r.ok) {

return 1;

}

LFortran::LPython::AST::ast_t* ast = r.result;

diagnostics.diagnostics.clear();

LFortran::Result<LFortran::ASR::TranslationUnit_t*>

r1 = LFortran::LPython::python_ast_to_asr(al, *ast, diagnostics, true,

compiler_options.disable_main, compiler_options.symtab_only, infile);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r1.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

return 2;

}

LFortran::ASR::TranslationUnit_t* asr = r1.result;

diagnostics.diagnostics.clear();

auto res = LFortran::asr_to_c(al, *asr, diagnostics,

compiler_options.platform, 0);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!res.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

return 3;

}

std::cout << res.result;

return 0;

const std::string &runtime_library_dir,

CompilerOptions &compiler_options) {

Allocator al(4*1024);

LFortran::diag::Diagnostics diagnostics;

LFortran::LocationManager lm;

lm.in_filename = infile;

std::string input = LFortran::read_file(infile);

lm.init_simple(input);

LFortran::Result<LFortran::LPython::AST::ast_t*> r1 = LFortran::parse_python_file(

al, runtime_library_dir, infile, diagnostics, compiler_options.new_parser);

if (r1.ok) {

LFortran::LPython::AST::ast_t* ast = r1.result;

LFortran::Result<LFortran::ASR::TranslationUnit_t*>

x = LFortran::LPython::python_ast_to_asr(al, *ast, diagnostics, true,

compiler_options.disable_main, compiler_options.symtab_only, infile);

if (!x.ok) {

std::cout << "{}\n";

return 0;

}

std::vector<LFortran::LPython::document_symbols> symbol_lists;

LFortran::LPython::document_symbols loc;

for (auto &a : x.result->m_global_scope->get_scope()) {

std::string symbol_name = a.first;

uint32_t first_line;

uint32_t last_line;

uint32_t first_column;

uint32_t last_column;

lm.pos_to_linecol(a.second->base.loc.first, first_line, first_column);

lm.pos_to_linecol(a.second->base.loc.last, last_line, last_column);

loc.first_column = first_column;

loc.last_column = last_column;

loc.first_line = first_line-1;

loc.last_line = last_line-1;

loc.symbol_name = symbol_name;

symbol_lists.push_back(loc);

}

rapidjson::Document test_output(rapidjson::kArrayType);

rapidjson::Document range_object(rapidjson::kObjectType);

rapidjson::Document start_detail(rapidjson::kObjectType);

rapidjson::Document end_detail(rapidjson::kObjectType);

rapidjson::Document location_object(rapidjson::kObjectType);

rapidjson::Document test_capture(rapidjson::kObjectType);

test_output.SetArray();

for (auto symbol : symbol_lists) {

uint32_t start_character = symbol.first_column;

uint32_t start_line = symbol.first_line;

uint32_t end_character = symbol.last_column;

uint32_t end_line = symbol.last_line;

std::string name = symbol.symbol_name;

range_object.SetObject();

rapidjson::Document::AllocatorType &allocator = range_object.GetAllocator();

start_detail.SetObject();

start_detail.AddMember("character", rapidjson::Value().SetInt(start_character), allocator);

start_detail.AddMember("line", rapidjson::Value().SetInt(start_line), allocator);

range_object.AddMember("start", start_detail, allocator);

end_detail.SetObject();

end_detail.AddMember("character", rapidjson::Value().SetInt(end_character), allocator);

end_detail.AddMember("line", rapidjson::Value().SetInt(end_line), allocator);

range_object.AddMember("end", end_detail, allocator);

location_object.SetObject();

location_object.AddMember("range", range_object, allocator);

location_object.AddMember("uri", rapidjson::Value().SetString("uri", allocator), allocator);

test_capture.SetObject();

test_capture.AddMember("kind", rapidjson::Value().SetInt(1), allocator);

test_capture.AddMember("location", location_object, allocator);

test_capture.AddMember("name", rapidjson::Value().SetString(name.c_str(), allocator), allocator);

test_output.PushBack(test_capture, test_output.GetAllocator());

}

rapidjson::StringBuffer buffer;

buffer.Clear();

rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);

test_output.Accept(writer);

std::string resp_str( buffer.GetString() );

std::cout << resp_str;

}

else {

std::cout << "{}\n";

}

return 0;

const std::string &runtime_library_dir,

CompilerOptions &compiler_options) {

Allocator al(4*1024);

LFortran::diag::Diagnostics diagnostics;

LFortran::LocationManager lm;

lm.in_filename = infile;

std::string input = LFortran::read_file(infile);

lm.init_simple(input);

LFortran::Result<LFortran::LPython::AST::ast_t*>

r1 = LFortran::parse_python_file(al, runtime_library_dir, infile,

diagnostics, compiler_options.new_parser);

if (r1.ok) {

LFortran::LPython::AST::ast_t* ast = r1.result;

LFortran::Result<LFortran::ASR::TranslationUnit_t*>

r = LFortran::LPython::python_ast_to_asr(al, *ast, diagnostics, true,

compiler_options.disable_main, compiler_options.symtab_only, infile);

}

std::vector<LFortran::LPython::error_highlight> diag_lists;

LFortran::LPython::error_highlight h;

for (auto &d : diagnostics.diagnostics) {

if (compiler_options.no_warnings && d.level != LFortran::diag::Level::Error) {

continue;

}

h.message = d.message;

h.severity = d.level;

for (auto label : d.labels) {

for (auto span : label.spans) {

uint32_t first_line;

uint32_t first_column;

uint32_t last_line;

uint32_t last_column;

lm.pos_to_linecol(span.loc.first, first_line, first_column);

lm.pos_to_linecol(span.loc.last, last_line, last_column);

h.first_column = first_column;

h.last_column = last_column;

h.first_line = first_line-1;

h.last_line = last_line-1;

diag_lists.push_back(h);

}

}

}

rapidjson::Document range_obj(rapidjson::kObjectType);

rapidjson::Document start_detail(rapidjson::kObjectType);

rapidjson::Document end_detail(rapidjson::kObjectType);

rapidjson::Document diag_results(rapidjson::kArrayType);

rapidjson::Document diag_capture(rapidjson::kObjectType);

rapidjson::Document message_send(rapidjson::kObjectType);

for (auto diag : diag_lists) {

uint32_t start_line = diag.first_line;

uint32_t start_column = diag.first_column;

uint32_t end_line = diag.last_line;

uint32_t end_column = diag.last_column;

uint32_t severity = diag.severity;

std::string msg = diag.message;

range_obj.SetObject();

rapidjson::Document::AllocatorType &allocator = range_obj.GetAllocator();

start_detail.SetObject();

start_detail.AddMember("line", rapidjson::Value().SetInt(start_line), allocator);

start_detail.AddMember("character", rapidjson::Value().SetInt(start_column), allocator);

range_obj.AddMember("start", start_detail, allocator);

end_detail.SetObject();

end_detail.AddMember("line", rapidjson::Value().SetInt(end_line), allocator);

end_detail.AddMember("character", rapidjson::Value().SetInt(end_column), allocator);

range_obj.AddMember("end", end_detail, allocator);

diag_results.SetArray();

diag_capture.AddMember("source", rapidjson::Value().SetString("lpyth", allocator), allocator);

diag_capture.AddMember("range", range_obj, allocator);

diag_capture.AddMember("message", rapidjson::Value().SetString(msg.c_str(), allocator), allocator);

diag_capture.AddMember("severity", rapidjson::Value().SetInt(severity), allocator);

diag_results.PushBack(diag_capture, allocator);

message_send.SetObject();

message_send.AddMember("uri", rapidjson::Value().SetString("uri", allocator), allocator);

message_send.AddMember("diagnostics", diag_results, allocator);

}

rapidjson::StringBuffer buffer;

buffer.Clear();

rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);

message_send.Accept(writer);

std::string resp_str( buffer.GetString() );

std::cout << resp_str;

return 0;

const std::string &runtime_library_dir,

LCompilers::PassManager& pass_manager,

CompilerOptions &compiler_options)

{

Allocator al(4*1024);

LFortran::diag::Diagnostics diagnostics;

LFortran::LocationManager lm;

lm.in_filename = infile;

std::string input = LFortran::read_file(infile);

lm.init_simple(input);

LFortran::Result<LFortran::LPython::AST::ast_t*> r = parse_python_file(

al, runtime_library_dir, infile, diagnostics, compiler_options.new_parser);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r.ok) {

return 1;

}

// Src -> AST -> ASR

LFortran::LPython::AST::ast_t* ast = r.result;

diagnostics.diagnostics.clear();

LFortran::Result<LFortran::ASR::TranslationUnit_t*>

r1 = LFortran::LPython::python_ast_to_asr(al, *ast, diagnostics, true,

compiler_options.disable_main, compiler_options.symtab_only, infile);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r1.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

return 2;

}

LFortran::ASR::TranslationUnit_t* asr = r1.result;

diagnostics.diagnostics.clear();

// ASR -> LLVM

LFortran::PythonCompiler fe(compiler_options);

LFortran::Result<std::unique_ptr<LFortran::LLVMModule>>

res = fe.get_llvm3(*asr, pass_manager, diagnostics);

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!res.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

return 3;

}

std::cout << (res.result)->str();

return 0;

if (time_report) {

for (auto &stage :times) {

std::cout << stage.first << ": " << stage.second << "ms" << std::endl;

}

}

const std::string &infile,

const std::string &outfile,

const std::string &runtime_library_dir,

LCompilers::PassManager& pass_manager,

CompilerOptions &compiler_options,

bool time_report, bool arg_c=false)

{

Allocator al(4*1024);

LFortran::diag::Diagnostics diagnostics;

LFortran::LocationManager lm;

lm.in_filename = infile;

std::vector<std::pair<std::string, double>>times;

auto file_reading_start = std::chrono::high_resolution_clock::now();

std::string input = LFortran::read_file(infile);

auto file_reading_end = std::chrono::high_resolution_clock::now();

times.push_back(std::make_pair("File reading", std::chrono::duration<double, std::milli>(file_reading_end - file_reading_start).count()));

lm.init_simple(input);

auto parsing_start = std::chrono::high_resolution_clock::now();

LFortran::Result<LFortran::LPython::AST::ast_t*> r = parse_python_file(

al, runtime_library_dir, infile, diagnostics, compiler_options.new_parser);

auto parsing_end = std::chrono::high_resolution_clock::now();

times.push_back(std::make_pair("Parsing", std::chrono::duration<double, std::milli>(parsing_end - parsing_start).count()));

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r.ok) {

print_time_report(times, time_report);

return 1;

}

// Src -> AST -> ASR

LFortran::LPython::AST::ast_t* ast = r.result;

diagnostics.diagnostics.clear();

auto ast_to_asr_start = std::chrono::high_resolution_clock::now();

LFortran::Result<LFortran::ASR::TranslationUnit_t*>

r1 = LFortran::LPython::python_ast_to_asr(al, *ast, diagnostics,

!(arg_c && compiler_options.disable_main),

compiler_options.disable_main, compiler_options.symtab_only, infile);

auto ast_to_asr_end = std::chrono::high_resolution_clock::now();

times.push_back(std::make_pair("AST to ASR", std::chrono::duration<double, std::milli>(ast_to_asr_end - ast_to_asr_start).count()));

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r1.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

print_time_report(times, time_report);

return 2;

}

LFortran::ASR::TranslationUnit_t* asr = r1.result;

if( compiler_options.disable_main ) {

int err = LFortran::LPython::save_pyc_files(*asr, infile);

if( err ) {

return err;

}

}

diagnostics.diagnostics.clear();

// ASR -> LLVM

LFortran::PythonCompiler fe(compiler_options);

LFortran::LLVMEvaluator e(compiler_options.target);

std::unique_ptr<LFortran::LLVMModule> m;

auto asr_to_llvm_start = std::chrono::high_resolution_clock::now();

LFortran::Result<std::unique_ptr<LFortran::LLVMModule>>

res = fe.get_llvm3(*asr, pass_manager, diagnostics);

auto asr_to_llvm_end = std::chrono::high_resolution_clock::now();

times.push_back(std::make_pair("ASR to LLVM", std::chrono::duration<double, std::milli>(asr_to_llvm_end - asr_to_llvm_start).count()));

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!res.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

print_time_report(times, time_report);

return 3;

}

m = std::move(res.result);

auto llvm_start = std::chrono::high_resolution_clock::now();

e.save_object_file(*(m->m_m), outfile);

auto llvm_end = std::chrono::high_resolution_clock::now();

times.push_back(std::make_pair("LLVM to binary", std::chrono::duration<double, std::milli>(llvm_end - llvm_start).count()));

print_time_report(times, time_report);

return 0;

const std::string &outfile,

const std::string &runtime_library_dir, Backend backend,

bool static_executable, bool kokkos,

CompilerOptions &compiler_options)

{

/*

#ifdef HAVE_LFORTRAN_LLVM

std::string t = (compiler_options.target == "") ? LFortran::LLVMEvaluator::get_default_target_triple() : compiler_options.target;

#else

std::string t = (compiler_options.platform == LFortran::Platform::Windows) ? "x86_64-pc-windows-msvc" : compiler_options.target;

#endif

if (backend == Backend::llvm) {

if (t == "x86_64-pc-windows-msvc") {

std::string cmd = "link /NOLOGO /OUT:" + outfile + " ";

for (auto &s : infiles) {

cmd += s + " ";

}

cmd += runtime_library_dir + "\\lpython_runtime_static.lib";

int err = system(cmd.c_str());

if (err) {

std::cout << "The command '" + cmd + "' failed." << std::endl;

return 10;

}

} else {

std::string CC = "cc";

char *env_CC = std::getenv("LFORTRAN_CC");

if (env_CC) CC = env_CC;

std::string base_path = "\"" + runtime_library_dir + "\"";

std::string options;

std::string runtime_lib = "lpython_runtime";

if (static_executable) {

if (compiler_options.platform != LFortran::Platform::macOS_Intel

&& compiler_options.platform != LFortran::Platform::macOS_ARM) {

options += " -static ";

}

runtime_lib = "lpython_runtime_static";

}

std::string cmd = CC + options + " -o " + outfile + " ";

for (auto &s : infiles) {

cmd += s + " ";

}

cmd += + " -L"

+ base_path + " -Wl,-rpath," + base_path + " -l" + runtime_lib + " -lm";

int err = system(cmd.c_str());

if (err) {

std::cout << "The command '" + cmd + "' failed." << std::endl;

return 10;

}

}

return 0;

} else if (backend == Backend::cpp) {

std::string CXX = "g++";

std::string options, post_options;

if (static_executable) {

options += " -static ";

}

if (compiler_options.openmp) {

options += " -fopenmp ";

}

if (kokkos) {

std::string kokkos_dir = get_kokkos_dir();

post_options += kokkos_dir + "/lib/libkokkoscontainers.a "

+ kokkos_dir + "/lib/libkokkoscore.a -ldl";

}

std::string cmd = CXX + options + " -o " + outfile + " ";

for (auto &s : infiles) {

cmd += s + " ";

}

cmd += + " -L";

cmd += " " + post_options + " -lm";

int err = system(cmd.c_str());

if (err) {

std::cout << "The command '" + cmd + "' failed." << std::endl;

return 10;

}

return 0;

} else if (backend == Backend::x86) {

std::string cmd = "cp " + infiles[0] + " " + outfile;

int err = system(cmd.c_str());

if (err) {

std::cout << "The command '" + cmd + "' failed." << std::endl;

return 10;

}

return 0;

} else {

LFORTRAN_ASSERT(false);

return 1;

}

{

LFortran::initialize();

#if defined(HAVE_LFORTRAN_STACKTRACE)

LFortran::print_stack_on_segfault();

#endif

try {

int dirname_length;

LFortran::get_executable_path(LFortran::binary_executable_path, dirname_length);

std::string runtime_library_dir = LFortran::get_runtime_library_dir();

std::string rtlib_header_dir = LFortran::get_runtime_library_header_dir();

Backend backend;

bool arg_S = false;

bool arg_c = false;

bool arg_v = false;

// bool arg_E = false;

// bool arg_g = false;

// std::string arg_J;

// std::vector<std::string> arg_I;

// std::vector<std::string> arg_l;

// std::vector<std::string> arg_L;

std::string arg_o;

std::vector<std::string> arg_files;

bool arg_version = false;

bool show_tokens = false;

bool show_ast = false;

bool show_asr = false;

bool show_cpp = false;

bool show_c = false;

bool show_document_symbols = false;

bool show_errors = false;

bool with_intrinsic_modules = false;

std::string arg_pass;

bool arg_no_color = false;

bool show_llvm = false;

bool show_asm = false;

bool time_report = false;

bool static_link = false;

std::string arg_backend = "llvm";

std::string arg_kernel_f;

bool print_targets = false;

bool print_rtlib_header_dir = false;

std::string arg_fmt_file;

// int arg_fmt_indent = 4;

// bool arg_fmt_indent_unit = false;

// bool arg_fmt_inplace = false;

// bool arg_fmt_no_color = false;

std::string arg_mod_file;

// bool arg_mod_show_asr = false;

// bool arg_mod_no_color = false;

std::string arg_pywrap_file;

std::string arg_pywrap_array_order="f";

CompilerOptions compiler_options;

LCompilers::PassManager lpython_pass_manager;

CLI::App app{"LPython: modern interactive LLVM-based Python compiler"};

// Standard options compatible with gfortran, gcc or clang

// We follow the established conventions

app.add_option("files", arg_files, "Source files");

// Should the following Options required for LPython??

// Instead we need support all the options from Python 3

app.add_flag("-S", arg_S, "Emit assembly, do not assemble or link");

app.add_flag("-c", arg_c, "Compile and assemble, do not link");

app.add_option("-o", arg_o, "Specify the file to place the output into");

app.add_flag("-v", arg_v, "Be more verbose");

// app.add_flag("-E", arg_E, "Preprocess only; do not compile, assemble or link");

// app.add_option("-l", arg_l, "Link library option");

// app.add_option("-L", arg_L, "Library path option");

// app.add_option("-I", arg_I, "Include path")->allow_extra_args(false);

// app.add_option("-J", arg_J, "Where to save mod files");

// app.add_flag("-g", arg_g, "Compile with debugging information");

// app.add_option("-D", compiler_options.c_preprocessor_defines, "Define <macro>=<value> (or 1 if <value> omitted)")->allow_extra_args(false);

app.add_flag("--version", arg_version, "Display compiler version information");

// LPython specific options

app.add_flag("--cpp", compiler_options.c_preprocessor, "Enable C preprocessing");

app.add_flag("--show-tokens", show_tokens, "Show tokens for the given python file and exit");

app.add_flag("--new-parser", compiler_options.new_parser, "Use the new LPython parser");

app.add_flag("--show-ast", show_ast, "Show AST for the given python file and exit");

app.add_flag("--show-asr", show_asr, "Show ASR for the given python file and exit");

app.add_flag("--show-llvm", show_llvm, "Show LLVM IR for the given file and exit");

app.add_flag("--show-cpp", show_cpp, "Show C++ translation source for the given python file and exit");

app.add_flag("--show-c", show_c, "Show C translation source for the given python file and exit");

app.add_flag("--show-asm", show_asm, "Show assembly for the given file and exit");

app.add_flag("--show-stacktrace", compiler_options.show_stacktrace, "Show internal stacktrace on compiler errors");

app.add_flag("--with-intrinsic-mods", with_intrinsic_modules, "Show intrinsic modules in ASR");

app.add_flag("--no-color", arg_no_color, "Turn off colored AST/ASR");

app.add_flag("--indent", compiler_options.indent, "Indented print ASR/AST");

app.add_flag("--tree", compiler_options.tree, "Tree structure print ASR/AST");

app.add_option("--pass", arg_pass, "Apply the ASR pass and show ASR (implies --show-asr)");

app.add_flag("--disable-main", compiler_options.disable_main, "Do not generate any code for the `main` function");

app.add_flag("--symtab-only", compiler_options.symtab_only, "Only create symbol tables in ASR (skip executable stmt)");

app.add_flag("--time-report", time_report, "Show compilation time report");

app.add_flag("--static", static_link, "Create a static executable");

app.add_flag("--no-warnings", compiler_options.no_warnings, "Turn off all warnings");

app.add_flag("--no-error-banner", compiler_options.no_error_banner, "Turn off error banner");

app.add_option("--backend", arg_backend, "Select a backend (llvm, cpp, x86)")->capture_default_str();

app.add_flag("--openmp", compiler_options.openmp, "Enable openmp");

app.add_flag("--fast", compiler_options.fast, "Best performance (disable strict standard compliance)");

app.add_option("--target", compiler_options.target, "Generate code for the given target")->capture_default_str();

app.add_flag("--print-targets", print_targets, "Print the registered targets");

app.add_flag("--get-rtlib-header-dir", print_rtlib_header_dir, "Print the path to the runtime library header file");

// LSP specific options

app.add_flag("--show-errors", show_errors, "Show errors when LSP is running in the background");

app.add_flag("--show-document-symbols", show_document_symbols, "Show symbols in lpython file");

if( compiler_options.fast ) {

lpython_pass_manager.use_optimization_passes();

}

/*

// fmt: Should LPython support `fmt` subcommand??

// CLI::App &fmt = *app.add_subcommand("fmt", "Format Fortran source files.");

// fmt.add_option("file", arg_fmt_file, "Fortran source file to format")->required();

// fmt.add_flag("-i", arg_fmt_inplace, "Modify <file> in-place (instead of writing to stdout)");

// fmt.add_option("--spaces", arg_fmt_indent, "Number of spaces to use for indentation")->capture_default_str();

// fmt.add_flag("--indent-unit", arg_fmt_indent_unit, "Indent contents of sub / fn / prog / mod");

// fmt.add_flag("--no-color", arg_fmt_no_color, "Turn off color when writing to stdout");

// kernel

CLI::App &kernel = *app.add_subcommand("kernel", "Run in Jupyter kernel mode.");

kernel.add_option("-f", arg_kernel_f, "The kernel connection file")->required();

// mod

// CLI::App &mod = *app.add_subcommand("mod", "Fortran mod file utilities.");

// mod.add_option("file", arg_mod_file, "Mod file (*.mod)")->required();

// mod.add_flag("--show-asr", arg_mod_show_asr, "Show ASR for the module");

// mod.add_flag("--no-color", arg_mod_no_color, "Turn off colored ASR");

// pywrap

CLI::App &pywrap = *app.add_subcommand("pywrap", "Python wrapper generator");

pywrap.add_option("file", arg_pywrap_file, "Fortran source file (*.f90)")->required();

pywrap.add_option("--array-order", arg_pywrap_array_order,

"Select array order (c, f)")->capture_default_str();

app.get_formatter()->column_width(25);

app.require_subcommand(0, 1);

CLI11_PARSE(app, argc, argv);

if (arg_version) {

std::string version = LFORTRAN_VERSION;

std::cout << "LPython version: " << version << std::endl;

std::cout << "Platform: ";

switch (compiler_options.platform) {

case (LFortran::Platform::Linux) : std::cout << "Linux"; break;

case (LFortran::Platform::macOS_Intel) : std::cout << "macOS Intel"; break;

case (LFortran::Platform::macOS_ARM) : std::cout << "macOS ARM"; break;

case (LFortran::Platform::Windows) : std::cout << "Windows"; break;

case (LFortran::Platform::FreeBSD) : std::cout << "FreeBSD"; break;

}

std::cout << std::endl;

#ifdef HAVE_LFORTRAN_LLVM

std::cout << "Default target: " << LFortran::LLVMEvaluator::get_default_target_triple() << std::endl;

#endif

return 0;

}

if (print_targets) {

#ifdef HAVE_LFORTRAN_LLVM

LFortran::LLVMEvaluator::print_targets();

return 0;

#else

std::cerr << "The --print-targets option requires the LLVM backend to be enabled. Recompile with `WITH_LLVM=yes`." << std::endl;

return 1;

#endif

}

if (print_rtlib_header_dir) {

do_print_rtlib_header_dir();

return 0;

}

compiler_options.use_colors = !arg_no_color;

// if (fmt) {

// return format(arg_fmt_file, arg_fmt_inplace, !arg_fmt_no_color,

// arg_fmt_indent, arg_fmt_indent_unit, compiler_options);

// }

if (kernel) {

std::cerr << "The kernel subcommand is not implemented yet for LPython." << std::endl;

return 1;

}

// if (mod) {

// if (arg_mod_show_asr) {

// Allocator al(1024*1024);

// LFortran::ASR::TranslationUnit_t *asr;

// asr = LFortran::mod_to_asr(al, arg_mod_file);

// std::cout << LFortran::pickle(*asr, !arg_mod_no_color) << std::endl;

// return 0;

// }

// return 0;

// }

if (pywrap) {

std::cerr << "Pywrap is not implemented yet." << std::endl;

return 1;

}

if (arg_backend == "llvm") {

backend = Backend::llvm;

} else if (arg_backend == "cpp") {

backend = Backend::cpp;

} else if (arg_backend == "x86") {

backend = Backend::x86;

} else {

std::cerr << "The backend must be one of: llvm, cpp, x86." << std::endl;

return 1;

}

if (arg_files.size() == 0) {

std::cerr << "Interactive prompt is not implemented yet in LPython" << std::endl;

return 1;

}

// TODO: for now we ignore the other filenames, only handle

// the first:

std::string arg_file = arg_files[0];

std::string outfile;

std::string basename;

basename = remove_extension(arg_file);

basename = remove_path(basename);

if (arg_o.size() > 0) {

outfile = arg_o;

} else if (arg_S) {

outfile = basename + ".s";

} else if (arg_c) {

outfile = basename + ".o";

} else if (show_tokens) {

outfile = basename + ".tok";

} else if (show_ast) {

outfile = basename + ".ast";