Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Remove redundant code #2417

Merged
merged 3 commits into from
Nov 12, 2023
Merged

Remove redundant code #2417

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
9e6d00a
Remove redundant pickle code
Shaikh-Ubaid Nov 12, 2023
945f4aa
Remove unused generate_visualize_html()
Shaikh-Ubaid Nov 12, 2023
2591cb8
Add LPython changes so refs stay the same
Shaikh-Ubaid Nov 12, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
13 changes: 7 additions & 6 deletions src/bin/lpython.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,8 +6,9 @@
#define CLI11_HAS_FILESYSTEM 0
#include <bin/CLI11.hpp>

#include <libasr/stacktrace.h>
#include <lpython/pickle.h>
#include <libasr/pickle.h>
#include <libasr/stacktrace.h>
#include <lpython/semantics/python_ast_to_asr.h>
#include <libasr/codegen/asr_to_llvm.h>
#include <libasr/codegen/asr_to_cpp.h>
Expand Down Expand Up @@ -221,15 +222,15 @@ int emit_asr(const std::string &infile,
pass_manager.apply_passes(al, asr, compiler_options.po, diagnostics);

if (compiler_options.po.tree) {
std::cout << LCompilers::LPython::pickle_tree(*asr,
std::cout << LCompilers::pickle_tree(*asr,
compiler_options.use_colors, with_intrinsic_modules) << std::endl;
} else if (compiler_options.po.json) {
std::cout << LCompilers::LPython::pickle_json(*asr, lm, with_intrinsic_modules) << std::endl;
std::cout << LCompilers::pickle_json(*asr, lm, false, with_intrinsic_modules) << std::endl;
} else if (compiler_options.po.visualize) {
std::string astr_data_json = LCompilers::LPython::pickle_json(*asr, lm, with_intrinsic_modules);
std::string astr_data_json = LCompilers::pickle_json(*asr, lm, false, with_intrinsic_modules);
return visualize_json(astr_data_json, compiler_options.platform);
} else {
std::cout << LCompilers::LPython::pickle(*asr, compiler_options.use_colors,
std::cout << LCompilers::pickle(*asr, compiler_options.use_colors,
compiler_options.indent, with_intrinsic_modules) << std::endl;
}
return 0;
Expand Down Expand Up @@ -1361,7 +1362,7 @@ EMSCRIPTEN_KEEPALIVE char* emit_asr_from_source(char *input) {
asr = LCompilers::LPython::python_ast_to_asr(al, lm, nullptr, *casted_ast, diagnostics, compiler_options, true, "__main__", "input");
out = diagnostics.render(lm, compiler_options);
if (asr.ok) {
out += LCompilers::LPython::pickle(*asr.result, compiler_options.use_colors, compiler_options.indent,
out += LCompilers::pickle(*asr.result, compiler_options.use_colors, compiler_options.indent,
false /* with_intrinsic_modules */);
}
}
Expand Down
4 changes: 2 additions & 2 deletions src/libasr/pickle.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -52,13 +52,13 @@ class ASRPickleVisitor :
}
void visit_Module(const ASR::Module_t &x) {
if (!show_intrinsic_modules &&
startswith(x.m_name, "lfortran_intrinsic_")) {
(x.m_intrinsic || startswith(x.m_name, "lfortran_intrinsic_") || startswith(x.m_name, "numpy"))) {
s.append("(");
if (use_colors) {
s.append(color(style::bold));
s.append(color(fg::magenta));
}
s.append("IntrinsicModule");
s.append(x.m_intrinsic ? "IntrinsicModule" : "Module");
if (use_colors) {
s.append(color(fg::reset));
s.append(color(style::reset));
Expand Down
232 changes: 0 additions & 232 deletions src/lpython/pickle.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,129 +28,6 @@ std::string pickle_python(AST::ast_t &ast, bool colors, bool indent) {
return v.get_str();
}

/********************** ASR Pickle *******************/
class ASRPickleVisitor :
public ASR::PickleBaseVisitor<ASRPickleVisitor>
{
public:
bool show_intrinsic_modules;

std::string get_str() {
return s;
}
void visit_symbol(const ASR::symbol_t &x) {
s.append(ASRUtils::symbol_parent_symtab(&x)->get_counter());
s.append(" ");
if (use_colors) {
s.append(color(fg::yellow));
}
s.append(ASRUtils::symbol_name(&x));
if (use_colors) {
s.append(color(fg::reset));
}
}
void visit_IntegerConstant(const ASR::IntegerConstant_t &x) {
s.append("(");
if (use_colors) {
s.append(color(style::bold));
s.append(color(fg::magenta));
}
s.append("IntegerConstant");
if (use_colors) {
s.append(color(fg::reset));
s.append(color(style::reset));
}
s.append(" ");
if (use_colors) {
s.append(color(fg::cyan));
}
s.append(std::to_string(x.m_n));
if (use_colors) {
s.append(color(fg::reset));
}
s.append(" ");
this->visit_ttype(*x.m_type);
s.append(")");
}
void visit_Module(const ASR::Module_t &x) {
// hide intrinsic modules and numpy module by default
if (!show_intrinsic_modules &&
(x.m_intrinsic || startswith(x.m_name, "numpy"))) {
s.append("(");
if (use_colors) {
s.append(color(style::bold));
s.append(color(fg::magenta));
}
s.append(x.m_intrinsic ? "IntrinsicModule" : "Module");
if (use_colors) {
s.append(color(fg::reset));
s.append(color(style::reset));
}
s.append(" ");
s.append(x.m_name);
s.append(")");
} else {
ASR::PickleBaseVisitor<ASRPickleVisitor>::visit_Module(x);
};
}

std::string convert_intrinsic_id(int x) {
std::string s;
if (use_colors) {
s.append(color(style::bold));
s.append(color(fg::green));
}
s.append(ASRUtils::get_intrinsic_name(x));
if (use_colors) {
s.append(color(fg::reset));
s.append(color(style::reset));
}
return s;
}

std::string convert_impure_intrinsic_id(int x) {
std::string s;
if (use_colors) {
s.append(color(style::bold));
s.append(color(fg::green));
}
s.append(ASRUtils::get_impure_intrinsic_name(x));
if (use_colors) {
s.append(color(fg::reset));
s.append(color(style::reset));
}
return s;
}

std::string convert_array_intrinsic_id(int x) {
std::string s;
if (use_colors) {
s.append(color(style::bold));
s.append(color(fg::green));
}
s.append(ASRUtils::get_array_intrinsic_name(x));
if (use_colors) {
s.append(color(fg::reset));
s.append(color(style::reset));
}
return s;
}
};

std::string pickle(ASR::asr_t &asr, bool colors, bool indent,
bool show_intrinsic_modules) {
ASRPickleVisitor v;
v.use_colors = colors;
v.indent = indent;
v.show_intrinsic_modules = show_intrinsic_modules;
v.visit_asr(asr);
return v.get_str();
}

std::string pickle(ASR::TranslationUnit_t &asr, bool colors, bool indent, bool show_intrinsic_modules) {
return pickle((ASR::asr_t &)asr, colors, indent, show_intrinsic_modules);
}

/********************** AST Pickle Tree *******************/
class ASTTreeVisitor : public AST::TreeBaseVisitor<ASTTreeVisitor>
{
Expand All @@ -167,31 +44,6 @@ std::string pickle_tree_python(AST::ast_t &ast, bool colors) {
return v.get_str();
}

/********************** ASR Pickle Tree *******************/
class ASRTreeVisitor :
public ASR::TreeBaseVisitor<ASRTreeVisitor>
{
public:
bool show_intrinsic_modules;

std::string get_str() {
return s;
}

};

std::string pickle_tree(ASR::asr_t &asr, bool colors, bool show_intrinsic_modules) {
ASRTreeVisitor v;
v.use_colors = colors;
v.show_intrinsic_modules = show_intrinsic_modules;
v.visit_asr(asr);
return v.get_str();
}

std::string pickle_tree(ASR::TranslationUnit_t &asr, bool colors, bool show_intrinsic_modules) {
return pickle_tree((ASR::asr_t &)asr, colors, show_intrinsic_modules);
}

/********************** AST Pickle Json *******************/
class ASTJsonVisitor :
public LPython::AST::JsonBaseVisitor<ASTJsonVisitor>
Expand All @@ -210,88 +62,4 @@ std::string pickle_json(LPython::AST::ast_t &ast, LocationManager &lm) {
return v.get_str();
}

/********************** ASR Pickle Json *******************/
class ASRJsonVisitor :
public ASR::JsonBaseVisitor<ASRJsonVisitor>
{
public:
bool show_intrinsic_modules;

using ASR::JsonBaseVisitor<ASRJsonVisitor>::JsonBaseVisitor;

std::string get_str() {
return s;
}

void visit_symbol(const ASR::symbol_t &x) {
s.append("\"");
s.append(ASRUtils::symbol_name(&x));
s.append(" (SymbolTable");
s.append(ASRUtils::symbol_parent_symtab(&x)->get_counter());
s.append(")\"");
}

void visit_Module(const ASR::Module_t &x) {
// hide intrinsic modules and numpy module by default
if (!show_intrinsic_modules &&
(x.m_intrinsic || startswith(x.m_name, "numpy"))) {
s.append("{");
inc_indent(); s.append("\n" + indtd);
s.append("\"node\": \"Module\"");
s.append(",\n" + indtd);
s.append("\"fields\": {");
inc_indent(); s.append("\n" + indtd);
s.append("\"name\": ");
s.append("\"" + std::string(x.m_name) + "\"");
s.append(",\n" + indtd);
s.append("\"dependencies\": ");
s.append("[");
if (x.n_dependencies > 0) {
inc_indent(); s.append("\n" + indtd);
for (size_t i=0; i<x.n_dependencies; i++) {
s.append("\"" + std::string(x.m_dependencies[i]) + "\"");
if (i < x.n_dependencies-1) {
s.append(",\n" + indtd);
};
}
dec_indent(); s.append("\n" + indtd);
}
s.append("]");
s.append(",\n" + indtd);
s.append("\"loaded_from_mod\": ");
if (x.m_loaded_from_mod) {
s.append("true");
} else {
s.append("false");
}
s.append(",\n" + indtd);
s.append("\"intrinsic\": ");
if (x.m_intrinsic) {
s.append("true");
} else {
s.append("false");
}
dec_indent(); s.append("\n" + indtd);
s.append("}");
s.append(",\n" + indtd);
append_location(s, x.base.base.loc.first, x.base.base.loc.last);
dec_indent(); s.append("\n" + indtd);
s.append("}");
} else {
ASR::JsonBaseVisitor<ASRJsonVisitor>::visit_Module(x);
}
}
};

std::string pickle_json(ASR::asr_t &asr, LocationManager &lm, bool show_intrinsic_modules) {
ASRJsonVisitor v(lm);
v.show_intrinsic_modules = show_intrinsic_modules;
v.visit_asr(asr);
return v.get_str();
}

std::string pickle_json(ASR::TranslationUnit_t &asr, LocationManager &lm, bool show_intrinsic_modules) {
return pickle_json((ASR::asr_t &)asr, lm, show_intrinsic_modules);
}

}
10 changes: 1 addition & 9 deletions src/lpython/pickle.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,20 +9,12 @@ namespace LCompilers::LPython {

// Pickle an ASR node
std::string pickle_python(AST::ast_t &ast, bool colors=false, bool indent=false);
std::string pickle(ASR::asr_t &asr, bool colors=false, bool indent=false,
bool show_intrinsic_modules=false);
std::string pickle(ASR::TranslationUnit_t &asr, bool colors=false,
bool indent=false, bool show_intrinsic_modules=false);

// Print the tree structure
std::string pickle_tree_python(AST::ast_t &ast, bool colors=true);
std::string pickle_tree(ASR::asr_t &asr, bool colors, bool show_intrinsic_modules);
std::string pickle_tree(ASR::TranslationUnit_t &asr, bool colors, bool show_intrinsic_modules);

// Print the ASR in json format
std::string pickle_json(AST::ast_t &ast, LocationManager &lm);
std::string pickle_json(ASR::asr_t &asr, LocationManager &lm, bool show_intrinsic_modules);
std::string pickle_json(ASR::TranslationUnit_t &asr, LocationManager &lm, bool show_intrinsic_modules);

}

#endif // LFORTRAN_PICKLE_H
Loading
Loading