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++ LPython 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 LCompilers::LCompilersException("LFORTRAN_KOKKOS_DIR is not defined");

{

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

// Src -> Tokens

Allocator al(64*1024*1024);

std::vector<int> toks;

std::vector<LCompilers::LPython::YYSTYPE> stypes;

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

LCompilers::diag::Diagnostics diagnostics;

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

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

if (res.ok) {

toks = res.result;

} else {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 1;

}

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

std::cout << LCompilers::LPython::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);

LCompilers::diag::Diagnostics diagnostics;

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

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

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

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

}

if (!r.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 1;

}

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

if (compiler_options.po.tree) {

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

compiler_options.use_colors) << std::endl;

} else if (compiler_options.po.json) {

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

std::cout << LCompilers::LPython::pickle_json(*ast, lm) << std::endl;

} else if (compiler_options.po.visualize) {

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

LCompilers::Result<std::string> r = LCompilers::LPython::pickle_json(*ast, lm);

return visualize_json(r.result, compiler_options.platform);

} else {

std::cout << LCompilers::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);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

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

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

if (!r1.ok) {

return 1;

}

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

diagnostics.diagnostics.clear();

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics,

compiler_options, true, "__main__", infile);

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

if (!r.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 2;

}

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

compiler_options.po.always_run = true;

compiler_options.po.run_fun = "f";

pass_manager.apply_passes(al, asr, compiler_options.po, diagnostics);

if (compiler_options.po.tree) {

std::cout << LCompilers::pickle_tree(*asr,

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

} else if (compiler_options.po.json) {

std::cout << LCompilers::pickle_json(*asr, lm, compiler_options.po.no_loc, with_intrinsic_modules) << std::endl;

} else if (compiler_options.po.visualize) {

std::string astr_data_json = LCompilers::pickle_json(*asr, lm, compiler_options.po.no_loc, with_intrinsic_modules);

return visualize_json(astr_data_json, compiler_options.platform);

} else {

std::cout << LCompilers::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);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

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

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

if (!r.ok) {

return 1;

}

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

diagnostics.diagnostics.clear();

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r1 = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", infile);

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

if (!r1.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 2;

}

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

diagnostics.diagnostics.clear();

auto res = LCompilers::asr_to_cpp(al, *asr, diagnostics, compiler_options, 0);

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

if (!res.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 3;

}

std::cout << res.result;

return 0;

const std::string &runtime_library_dir,

LCompilers::PassManager& pass_manager,

CompilerOptions &compiler_options)

{

Allocator al(4*1024);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

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

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

if (!r.ok) {

return 1;

}

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

diagnostics.diagnostics.clear();

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r1 = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", infile);

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

if (!r1.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 2;

}

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

// Apply ASR passes

pass_manager.use_default_passes(true);

compiler_options.po.always_run = true;

compiler_options.po.run_fun = "f";

pass_manager.apply_passes(al, asr, compiler_options.po, diagnostics);

diagnostics.diagnostics.clear();

auto res = LCompilers::asr_to_c(al, *asr, diagnostics, compiler_options, 0);

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

if (!res.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 3;

}

std::cout << res.result;

return 0;

const std::string &runtime_library_dir, LCompilers::PassManager& pass_manager,

CompilerOptions &compiler_options)

{

Allocator al(4*1024);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

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

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

if (!r.ok) {

return 1;

}

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

diagnostics.diagnostics.clear();

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r1 = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", infile);

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

if (!r1.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 2;

}

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

compiler_options.po.run_fun = "f";

compiler_options.po.always_run = true;

pass_manager.use_default_passes(true);

pass_manager.apply_passes(al, asr, compiler_options.po, diagnostics);

diagnostics.diagnostics.clear();

auto res = LCompilers::asr_to_c(al, *asr, diagnostics, compiler_options, 0);

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

if (!res.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 3;

}

FILE *fp;

fp = fopen(outfile.c_str(), "w");

fputs(res.result.c_str(), fp);

fclose(fp);

return 0;

const std::string &runtime_library_dir,

CompilerOptions &compiler_options)

{

Allocator al(4*1024);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

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

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

if (!r.ok) {

return 1;

}

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

diagnostics.diagnostics.clear();

// AST -> ASR

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r1 = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", infile);

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

if (!r1.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 2;

}

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

diagnostics.diagnostics.clear();

// ASR -> LPython

bool color = false;

int indent = 0;

LCompilers::Result<std::string> res = LCompilers::asr_to_python(al, *asr, diagnostics, compiler_options, color, indent);

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

if (!res.ok) {

LCOMPILERS_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);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

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

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

if (!r.ok) {

return 1;

}

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

diagnostics.diagnostics.clear();

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r1 = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", infile);

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

if (!r1.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 2;

}

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

diagnostics.diagnostics.clear();

LCompilers::Result<LCompilers::Vec<uint8_t>> r2 = LCompilers::asr_to_wasm_bytes_stream(*asr, al, diagnostics, compiler_options);

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

if (!r2.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 3;

}

diagnostics.diagnostics.clear();

LCompilers::Result<std::string> res = LCompilers::wasm_to_wat(r2.result, al, diagnostics);

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

if (!res.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 4;

}

std::cout << res.result;

return 0;

const std::string &runtime_library_dir,

CompilerOptions &compiler_options) {

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

Allocator al(4*1024);

LCompilers::LocationManager lm;

LCompilers::diag::Diagnostics diagnostics;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

lm.file_ends.push_back(input.size());

}

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

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

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

if (!r.ok) {

return 1;

}

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

diagnostics.diagnostics.clear();

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r1 = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", infile);

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

if (r1.ok) {

LCompilers::PassManager pass_manager;

compiler_options.po.always_run = true;

compiler_options.po.run_fun = "f";

pass_manager.dump_all_passes(al, r1.result, compiler_options.po, diagnostics, lm);

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

} else {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 1;

}

return 0;

const std::string &runtime_library_dir,

CompilerOptions &compiler_options) {

Allocator al(4*1024);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

r1 = parse_python_file(al, runtime_library_dir,

infile, diagnostics, 0, compiler_options.new_parser);

if (r1.ok) {

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

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

x = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", infile);

if (!x.ok) {

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

return 0;

}

std::vector<LCompilers::document_symbols> symbol_lists;

LCompilers::document_symbols loc;

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

std::string symbol_name = a.first;

uint32_t first_line;

uint32_t last_line;

uint32_t first_column;

uint32_t last_column;

std::string filename;

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

first_column, filename);

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

last_column, filename);

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;

loc.filename = filename;

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);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

r1 = parse_python_file(al, runtime_library_dir, infile,

diagnostics, 0, compiler_options.new_parser);

if (r1.ok) {

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

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", infile);

}

std::vector<LCompilers::error_highlight> diag_lists;

LCompilers::error_highlight h;

for (auto &d : diagnostics.diagnostics) {

if (compiler_options.no_warnings && d.level != LCompilers::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;

std::string filename;

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

filename);

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

filename);

h.first_column = first_column;

h.last_column = last_column;

h.first_line = first_line-1;

h.last_line = last_line-1;

h.filename = filename;

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;

if (time_report) {

for (auto &stage :times) {

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

}

}

const std::string &runtime_library_dir,

LCompilers::PassManager& pass_manager,

CompilerOptions &compiler_options)

{

Allocator al(4*1024);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

lm.init_simple(input);

lm.file_ends.push_back(input.size());

}

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

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

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

if (!r.ok) {

return 1;

}

// Src -> AST -> ASR

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

diagnostics.diagnostics.clear();

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r1 = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", infile);

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

if (!r1.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 2;

}

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

diagnostics.diagnostics.clear();

// ASR -> LLVM

LCompilers::PythonCompiler fe(compiler_options);

LCompilers::Result<std::unique_ptr<LCompilers::LLVMModule>>

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

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

if (!res.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 3;

}

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

return 0;

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);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

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

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

std::string input = LCompilers::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);

lm.file_ends.push_back(input.size());

}

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

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

al, runtime_library_dir, infile, diagnostics, 0, 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(lm, compiler_options);

if (!r.ok) {

print_time_report(times, time_report);

return 1;

}

// Src -> AST -> ASR

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

diagnostics.diagnostics.clear();

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

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r1 = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options,

!(arg_c && compiler_options.po.disable_main), "__main__", 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(lm, compiler_options);

if (!r1.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

print_time_report(times, time_report);

return 2;

}

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

if( compiler_options.po.disable_main ) {

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

if( err ) {

return err;

}

}

diagnostics.diagnostics.clear();

// ASR -> LLVM

if (compiler_options.emit_debug_info) {

#ifndef HAVE_RUNTIME_STACKTRACE

diagnostics.add(LCompilers::diag::Diagnostic(

"The `runtime stacktrace` is not enabled. To get the stacktraces, "

"re-build LPython with `-DWITH_RUNTIME_STACKTRACE=yes`",

LCompilers::diag::Level::Error,

LCompilers::diag::Stage::Semantic, {})

);

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

return 1;

#endif

}

LCompilers::PythonCompiler fe(compiler_options);

LCompilers::LLVMEvaluator e(compiler_options.target);

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

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

LCompilers::Result<std::unique_ptr<LCompilers::LLVMModule>>

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

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(lm, compiler_options);

if (!res.ok) {

LCOMPILERS_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 &infile,

const std::string &outfile,

const std::string &runtime_library_dir,

CompilerOptions &compiler_options,

bool time_report)

{

Allocator al(4*1024);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

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

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

std::string input = LCompilers::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);

lm.file_ends.push_back(input.size());

}

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

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

al, runtime_library_dir, infile, diagnostics, 0, 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(lm, compiler_options);

if (!r.ok) {

print_time_report(times, time_report);

return 1;

}

// Src -> AST -> ASR

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

diagnostics.diagnostics.clear();

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

LCompilers::Result<LCompilers::ASR::TranslationUnit_t*>

r1 = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *ast, diagnostics, compiler_options, true, "__main__", 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(lm, compiler_options);

if (!r1.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

print_time_report(times, time_report);

return 2;

}

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

if( compiler_options.po.disable_main ) {

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

if( err ) {

return err;

}

}

diagnostics.diagnostics.clear();

// ASR -> WASM

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

LCompilers::Result<int> res = LCompilers::asr_to_wasm(*asr, al, outfile, time_report, diagnostics, compiler_options);

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

times.push_back(std::make_pair("ASR to WASM", std::chrono::duration<double, std::milli>(asr_to_wasm_end - asr_to_wasm_start).count()));

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

print_time_report(times, time_report);

if (!res.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return 3;

}

return 0;

const std::string &infile,

const std::string &outfile,

const std::string &runtime_library_dir,

CompilerOptions &compiler_options,

bool time_report)

{

Allocator al(4*1024);

LCompilers::diag::Diagnostics diagnostics;

LCompilers::LocationManager lm;

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

{

LCompilers::LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

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

std::string input = LCompilers::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()));