Skip to content

Commit 56d5723

Browse files
ubaidskubaidsk
authored
Merge pull request #2717 from Vipul-Cariappa/unsigned
Support to print `u32` and `u64` in REPL
2 parents 2420448 + abead67 commit 56d5723

File tree

5 files changed

+218
-7
lines changed

5 files changed

+218
-7
lines changed

‎src/bin/lpython.cpp‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -900,6 +900,18 @@ int interactive_python_repl(
900900
std::cout << r.i64 << std::endl;
901901
break;
902902
}
903+
case (LCompilers::PythonCompiler::EvalResult::unsignedInteger4) : {
904+
if (verbose) std::cout << "Return type: unsigned integer" << std::endl;
905+
if (verbose) section("Result:");
906+
std::cout << r.u32 << std::endl;
907+
break;
908+
}
909+
case (LCompilers::PythonCompiler::EvalResult::unsignedInteger8) : {
910+
if (verbose) std::cout << "Return type: unsigned integer(8)" << std::endl;
911+
if (verbose) section("Result:");
912+
std::cout << r.u64 << std::endl;
913+
break;
914+
}
903915
case (LCompilers::PythonCompiler::EvalResult::real4) : {
904916
if (verbose) std::cout << "Return type: real" << std::endl;
905917
if (verbose) section("Result:");

‎src/libasr/pass/global_stmts.cpp‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -62,6 +62,23 @@ void pass_wrap_global_stmts(Allocator &al,
6262
fn_scope->add_symbol(std::string(var_name), down_cast<ASR::symbol_t>(return_var));
6363
target = return_var_ref;
6464
idx++;
65+
} else if (ASRUtils::expr_type(value)->type == ASR::ttypeType::UnsignedInteger) {
66+
s.from_str(al, fn_name_s + std::to_string(idx));
67+
var_name = s.c_str(al);
68+
69+
int a_kind = down_cast<ASR::UnsignedInteger_t>(ASRUtils::expr_type(value))->m_kind;
70+
71+
type = ASRUtils::TYPE(ASR::make_UnsignedInteger_t(al, loc, a_kind));
72+
return_var = ASR::make_Variable_t(al, loc,
73+
fn_scope, var_name, nullptr, 0, ASRUtils::intent_local, nullptr, nullptr,
74+
ASR::storage_typeType::Default, type,
75+
nullptr, ASR::abiType::BindC,
76+
ASR::Public, ASR::presenceType::Required, false);
77+
return_var_ref = EXPR(ASR::make_Var_t(al, loc,
78+
down_cast<ASR::symbol_t>(return_var)));
79+
fn_scope->add_symbol(std::string(var_name), down_cast<ASR::symbol_t>(return_var));
80+
target = return_var_ref;
81+
idx++;
6582
} else if (ASRUtils::expr_type(value)->type == ASR::ttypeType::Real) {
6683
s.from_str(al, fn_name_s + std::to_string(idx));
6784
var_name = s.c_str(al);

‎src/lpython/python_evaluator.cpp‎

Lines changed: 24 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -128,13 +128,31 @@ Result<PythonCompiler::EvalResult> PythonCompiler::evaluate(
128128
e->add_module(std::move(m));
129129
if (call_run_fn) {
130130
if (return_type == "integer4") {
131-
int32_t r = e->int32fn(run_fn);
132-
result.type = EvalResult::integer4;
133-
result.i32 = r;
131+
ASR::symbol_t *fn = ASR::down_cast<ASR::Module_t>(symbol_table->resolve_symbol(module_name))
132+
->m_symtab->get_symbol(run_fn);
133+
LCOMPILERS_ASSERT(fn)
134+
if (ASRUtils::get_FunctionType(fn)->m_return_var_type->type == ASR::ttypeType::UnsignedInteger) {
135+
uint32_t r = e->int32fn(run_fn);
136+
result.type = EvalResult::unsignedInteger4;
137+
result.u32 = r;
138+
} else {
139+
int32_t r = e->int32fn(run_fn);
140+
result.type = EvalResult::integer4;
141+
result.i32 = r;
142+
}
134143
} else if (return_type == "integer8") {
135-
int64_t r = e->int64fn(run_fn);
136-
result.type = EvalResult::integer8;
137-
result.i64 = r;
144+
ASR::symbol_t *fn = ASR::down_cast<ASR::Module_t>(symbol_table->resolve_symbol(module_name))
145+
->m_symtab->get_symbol(run_fn);
146+
LCOMPILERS_ASSERT(fn)
147+
if (ASRUtils::get_FunctionType(fn)->m_return_var_type->type == ASR::ttypeType::UnsignedInteger) {
148+
uint64_t r = e->int64fn(run_fn);
149+
result.type = EvalResult::unsignedInteger8;
150+
result.u64 = r;
151+
} else {
152+
int64_t r = e->int64fn(run_fn);
153+
result.type = EvalResult::integer8;
154+
result.i64 = r;
155+
}
138156
} else if (return_type == "real4") {
139157
float r = e->floatfn(run_fn);
140158
result.type = EvalResult::real4;

‎src/lpython/python_evaluator.h‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -37,11 +37,13 @@ class PythonCompiler
3737

3838
struct EvalResult {
3939
enum {
40-
integer4, integer8, real4, real8, complex4, complex8, statement, none
40+
integer4, integer8, unsignedInteger4, unsignedInteger8, real4, real8, complex4, complex8, statement, none
4141
} type;
4242
union {
4343
int32_t i32;
4444
int64_t i64;
45+
uint32_t u32;
46+
uint64_t u64;
4547
float f32;
4648
double f64;
4749
struct {float re, im;} c32;

‎src/lpython/tests/test_llvm.cpp‎

Lines changed: 162 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -784,3 +784,165 @@ TEST_CASE("PythonCompiler i64 declaration") {
784784
CHECK(r.result.type == PythonCompiler::EvalResult::integer8);
785785
CHECK(r.result.i64 == 14);
786786
}
787+
788+
TEST_CASE("PythonCompiler u32 expressions") {
789+
CompilerOptions cu;
790+
cu.po.disable_main = true;
791+
cu.emit_debug_line_column = false;
792+
cu.generate_object_code = false;
793+
cu.interactive = true;
794+
cu.po.runtime_library_dir = LCompilers::LPython::get_runtime_library_dir();
795+
PythonCompiler e(cu);
796+
LCompilers::Result<PythonCompiler::EvalResult>
797+
798+
r = e.evaluate2("u32(1)");
799+
CHECK(r.ok);
800+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger4);
801+
CHECK(r.result.u32 == 1);
802+
803+
r = e.evaluate2("u32(1) + u32(2)");
804+
CHECK(r.ok);
805+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger4);
806+
CHECK(r.result.u32 == 3);
807+
808+
r = e.evaluate2("u32(20) - u32(10)");
809+
CHECK(r.ok);
810+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger4);
811+
CHECK(r.result.u32 == 10);
812+
813+
r = e.evaluate2("u32(1) * u32(2)");
814+
CHECK(r.ok);
815+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger4);
816+
CHECK(r.result.u32 == 2);
817+
818+
r = e.evaluate2("u32(3) ** u32(3)");
819+
CHECK(r.ok);
820+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger4);
821+
CHECK(r.result.u32 == 27);
822+
823+
r = e.evaluate2("u32(4) // u32(2)");
824+
CHECK(r.ok);
825+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger4);
826+
CHECK(r.result.u32 == 2);
827+
828+
r = e.evaluate2("u32(4) / u32(2)");
829+
CHECK(r.ok);
830+
CHECK(r.result.type == PythonCompiler::EvalResult::real8);
831+
CHECK(r.result.f64 == 2);
832+
}
833+
834+
TEST_CASE("PythonCompiler u32 declaration") {
835+
CompilerOptions cu;
836+
cu.po.disable_main = true;
837+
cu.emit_debug_line_column = false;
838+
cu.generate_object_code = false;
839+
cu.interactive = true;
840+
cu.po.runtime_library_dir = LCompilers::LPython::get_runtime_library_dir();
841+
PythonCompiler e(cu);
842+
LCompilers::Result<PythonCompiler::EvalResult>
843+
844+
r = e.evaluate2("i: u32");
845+
CHECK(r.ok);
846+
CHECK(r.result.type == PythonCompiler::EvalResult::none);
847+
r = e.evaluate2("i = u32(5)");
848+
CHECK(r.ok);
849+
CHECK(r.result.type == PythonCompiler::EvalResult::statement);
850+
r = e.evaluate2("i");
851+
CHECK(r.ok);
852+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger4);
853+
CHECK(r.result.u32 == 5);
854+
855+
r = e.evaluate2("j: u32 = u32(9)");
856+
CHECK(r.ok);
857+
CHECK(r.result.type == PythonCompiler::EvalResult::none);
858+
r = e.evaluate2("j");
859+
CHECK(r.ok);
860+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger4);
861+
CHECK(r.result.u32 == 9);
862+
863+
r = e.evaluate2("i * j");
864+
CHECK(r.ok);
865+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger4);
866+
CHECK(r.result.u32 == 45);
867+
}
868+
869+
TEST_CASE("PythonCompiler u64 expressions") {
870+
CompilerOptions cu;
871+
cu.po.disable_main = true;
872+
cu.emit_debug_line_column = false;
873+
cu.generate_object_code = false;
874+
cu.interactive = true;
875+
cu.po.runtime_library_dir = LCompilers::LPython::get_runtime_library_dir();
876+
PythonCompiler e(cu);
877+
LCompilers::Result<PythonCompiler::EvalResult>
878+
879+
r = e.evaluate2("u64(1)");
880+
CHECK(r.ok);
881+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger8);
882+
CHECK(r.result.u64 == 1);
883+
884+
r = e.evaluate2("u64(1) + u64(2)");
885+
CHECK(r.ok);
886+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger8);
887+
CHECK(r.result.u64 == 3);
888+
889+
r = e.evaluate2("u64(20) - u64(10)");
890+
CHECK(r.ok);
891+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger8);
892+
CHECK(r.result.u64 == 10);
893+
894+
r = e.evaluate2("u64(1) * u64(2)");
895+
CHECK(r.ok);
896+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger8);
897+
CHECK(r.result.u64 == 2);
898+
899+
r = e.evaluate2("u64(3) ** u64(3)");
900+
CHECK(r.ok);
901+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger8);
902+
CHECK(r.result.u64 == 27);
903+
904+
r = e.evaluate2("u64(4) // u64(2)");
905+
CHECK(r.ok);
906+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger8);
907+
CHECK(r.result.u64 == 2);
908+
909+
r = e.evaluate2("u64(4) / u64(2)");
910+
CHECK(r.ok);
911+
CHECK(r.result.type == PythonCompiler::EvalResult::real8);
912+
CHECK(r.result.f64 == 2);
913+
}
914+
915+
TEST_CASE("PythonCompiler u64 declaration") {
916+
CompilerOptions cu;
917+
cu.po.disable_main = true;
918+
cu.emit_debug_line_column = false;
919+
cu.generate_object_code = false;
920+
cu.interactive = true;
921+
cu.po.runtime_library_dir = LCompilers::LPython::get_runtime_library_dir();
922+
PythonCompiler e(cu);
923+
LCompilers::Result<PythonCompiler::EvalResult>
924+
925+
r = e.evaluate2("i: u64");
926+
CHECK(r.ok);
927+
CHECK(r.result.type == PythonCompiler::EvalResult::none);
928+
r = e.evaluate2("i = u64(5)");
929+
CHECK(r.ok);
930+
CHECK(r.result.type == PythonCompiler::EvalResult::statement);
931+
r = e.evaluate2("i");
932+
CHECK(r.ok);
933+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger8);
934+
CHECK(r.result.u64 == 5);
935+
936+
r = e.evaluate2("j: u64 = u64(9)");
937+
CHECK(r.ok);
938+
CHECK(r.result.type == PythonCompiler::EvalResult::none);
939+
r = e.evaluate2("j");
940+
CHECK(r.ok);
941+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger8);
942+
CHECK(r.result.u64 == 9);
943+
944+
r = e.evaluate2("i * j");
945+
CHECK(r.ok);
946+
CHECK(r.result.type == PythonCompiler::EvalResult::unsignedInteger8);
947+
CHECK(r.result.u64 == 45);
948+
}

0 commit comments

Comments
 (0)