xxq250
/
Nasal-Interpreter
mirror of https://github.com/ValKmjolnir/Nasal-Interpreter.git
1
0
Fork 0
Code Issues Actions 1 Packages Projects Releases Wiki Activity

✨ avoid compilation warnings

This commit is contained in:
ValKmjolnir 2023-11-23 21:35:11 +08:00
parent 01ceaf7e66
commit cacf0ae86a
6 changed files with 66 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/io_lib.cpp
View File

@ -10,7 +10,7 @@ void filehandle_destructor(void* ptr) {
var builtin_readfile(context* ctx, gc* ngc) { var builtin_readfile(context* ctx, gc* ngc) {
auto filename = ctx->localr[1]; auto filename = ctx->localr[1];
if (filename.type!=vm_type::vm_str) { if (!filename.is_str()) {
return nas_err("io::readfile", "\"filename\" must be string"); return nas_err("io::readfile", "\"filename\" must be string");
} }
std::ifstream in(filename.str(), std::ios::binary); std::ifstream in(filename.str(), std::ios::binary);
@ -25,7 +25,7 @@ var builtin_fout(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
auto filename = local[1]; auto filename = local[1];
auto source = local[2]; auto source = local[2];
if (filename.type!=vm_type::vm_str) { if (!filename.is_str()) {
return nas_err("io::fout", "\"filename\" must be string"); return nas_err("io::fout", "\"filename\" must be string");
} }
std::ofstream out(filename.str()); std::ofstream out(filename.str());
@ -38,7 +38,7 @@ var builtin_fout(context* ctx, gc* ngc) {
var builtin_exists(context* ctx, gc* ngc) { var builtin_exists(context* ctx, gc* ngc) {
auto filename = ctx->localr[1]; auto filename = ctx->localr[1];
if (filename.type!=vm_type::vm_str) { if (!filename.is_str()) {
return zero; return zero;
} }
return access(filename.str().c_str(), F_OK)!=-1? one:zero; return access(filename.str().c_str(), F_OK)!=-1? one:zero;
@ -48,10 +48,10 @@ var builtin_open(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
auto name = local[1]; auto name = local[1];
auto mode = local[2]; auto mode = local[2];
if (name.type!=vm_type::vm_str) { if (!name.is_str()) {
return nas_err("io::open", "\"filename\" must be string"); return nas_err("io::open", "\"filename\" must be string");
} }
if (mode.type!=vm_type::vm_str) { if (!mode.is_str()) {
return nas_err("io::open", "\"mode\" must be string"); return nas_err("io::open", "\"mode\" must be string");
} }
auto file_descriptor = fopen(name.str().c_str(), mode.str().c_str()); auto file_descriptor = fopen(name.str().c_str(), mode.str().c_str());
@ -82,10 +82,10 @@ var builtin_read(context* ctx, gc* ngc) {
if (!file_descriptor.object_check(file_type_name)) { if (!file_descriptor.object_check(file_type_name)) {
return nas_err("io::read", "not a valid filehandle"); return nas_err("io::read", "not a valid filehandle");
} }
if (buffer.type!=vm_type::vm_str || buffer.val.gcobj->unmutable) { if (!buffer.is_str() || buffer.val.gcobj->unmutable) {
return nas_err("io::read", "\"buf\" must be mutable string"); return nas_err("io::read", "\"buf\" must be mutable string");
} }
if (length.type!=vm_type::vm_num) { if (!length.is_num()) {
return nas_err("io::read", "\"len\" must be number"); return nas_err("io::read", "\"len\" must be number");
} }
if (length.num()<=0 || length.num()>=(1<<30)) { if (length.num()<=0 || length.num()>=(1<<30)) {
@ -112,7 +112,7 @@ var builtin_write(context* ctx, gc* ngc) {
if (!file_descriptor.object_check(file_type_name)) { if (!file_descriptor.object_check(file_type_name)) {
return nas_err("io::write", "not a valid filehandle"); return nas_err("io::write", "not a valid filehandle");
} }
if (source.type!=vm_type::vm_str) { if (!source.is_str()) {
return nas_err("io::write", "\"str\" must be string"); return nas_err("io::write", "\"str\" must be string");
} }
return var::num(static_cast<f64>(fwrite( return var::num(static_cast<f64>(fwrite(
@ -170,7 +170,7 @@ var builtin_readln(context* ctx, gc* ngc) {
var builtin_stat(context* ctx, gc* ngc) { var builtin_stat(context* ctx, gc* ngc) {
auto name = ctx->localr[1]; auto name = ctx->localr[1];
if (name.type!=vm_type::vm_str) { if (!name.is_str()) {
return nas_err("io::stat", "\"filename\" must be string"); return nas_err("io::stat", "\"filename\" must be string");
} }
struct stat buffer; struct stat buffer;

4
src/math_lib.cpp
View File

@ -5,7 +5,7 @@ namespace nasal {
var builtin_pow(context* ctx, gc* ngc) { var builtin_pow(context* ctx, gc* ngc) {
auto x = ctx->localr[1]; auto x = ctx->localr[1];
auto y = ctx->localr[2]; auto y = ctx->localr[2];
if (x.type!=vm_type::vm_num || y.type!=vm_type::vm_num) { if (!x.is_num() || !y.is_num()) {
return var::num(std::nan("")); return var::num(std::nan(""));
} }
return var::num(std::pow(x.num(), y.num())); return var::num(std::pow(x.num(), y.num()));
@ -49,7 +49,7 @@ var builtin_sqrt(context* ctx, gc* ngc) {
var builtin_atan2(context* ctx, gc* ngc) { var builtin_atan2(context* ctx, gc* ngc) {
auto x = ctx->localr[1]; auto x = ctx->localr[1];
auto y = ctx->localr[2]; auto y = ctx->localr[2];
if (x.type!=vm_type::vm_num || y.type!=vm_type::vm_num) { if (!x.is_num() || !y.is_num()) {
return var::num(std::nan("")); return var::num(std::nan(""));
} }
return var::num(atan2(y.num(), x.num())); return var::num(atan2(y.num(), x.num()));

60
src/nasal_builtin.cpp
View File

@ -33,7 +33,7 @@ var builtin_append(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
var vec = local[1]; var vec = local[1];
var elem = local[2]; var elem = local[2];
if (vec.type!=vm_type::vm_vec) { if (!vec.is_vec()) {
return nas_err("append", "\"vec\" must be vector"); return nas_err("append", "\"vec\" must be vector");
} }
auto& v = vec.vec().elems; auto& v = vec.vec().elems;
@ -47,10 +47,10 @@ var builtin_setsize(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
var vec = local[1]; var vec = local[1];
var size = local[2]; var size = local[2];
if (vec.type!=vm_type::vm_vec) { if (!vec.is_vec()) {
return nas_err("setsize", "\"vec\" must be vector"); return nas_err("setsize", "\"vec\" must be vector");
} }
if (size.type!=vm_type::vm_num || size.num()<0) { if (!size.is_num() || size.num()<0) {
return nil; return nil;
} }
vec.vec().elems.resize(static_cast<i64>(size.num()), nil); vec.vec().elems.resize(static_cast<i64>(size.num()), nil);
@ -59,7 +59,7 @@ var builtin_setsize(context* ctx, gc* ngc) {
var builtin_system(context* ctx, gc* ngc) { var builtin_system(context* ctx, gc* ngc) {
auto str = ctx->localr[1]; auto str = ctx->localr[1];
if (str.type!=vm_type::vm_str) { if (!str.is_str()) {
return var::num(-1); return var::num(-1);
} }
return var::num(static_cast<f64>(system(str.str().c_str()))); return var::num(static_cast<f64>(system(str.str().c_str())));
@ -69,7 +69,7 @@ var builtin_input(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
var end = local[1]; var end = local[1];
var ret = ngc->alloc(vm_type::vm_str); var ret = ngc->alloc(vm_type::vm_str);
if (end.type!=vm_type::vm_str || end.str().length()>1 || !end.str().length()) { if (!end.is_str() || end.str().length()>1 || !end.str().length()) {
std::cin >> ret.str(); std::cin >> ret.str();
} else { } else {
std::getline(std::cin, ret.str(), end.str()[0]); std::getline(std::cin, ret.str(), end.str()[0]);
@ -81,10 +81,10 @@ var builtin_split(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
var delimeter = local[1]; var delimeter = local[1];
var str = local[2]; var str = local[2];
if (delimeter.type!=vm_type::vm_str) { if (!delimeter.is_str()) {
return nas_err("split", "\"separator\" must be string"); return nas_err("split", "\"separator\" must be string");
} }
if (str.type!=vm_type::vm_str) { if (!str.is_str()) {
return nas_err("split", "\"str\" must be string"); return nas_err("split", "\"str\" must be string");
} }
const auto& deli = delimeter.str(); const auto& deli = delimeter.str();
@ -119,7 +119,7 @@ var builtin_split(context* ctx, gc* ngc) {
var builtin_rand(context* ctx, gc* ngc) { var builtin_rand(context* ctx, gc* ngc) {
auto val = ctx->localr[1]; auto val = ctx->localr[1];
if (val.type!=vm_type::vm_num && val.type!=vm_type::vm_nil) { if (!val.is_num() && !val.is_nil()) {
return nas_err("rand", "\"seed\" must be nil or number"); return nas_err("rand", "\"seed\" must be nil or number");
} }
if (val.is_num()) { if (val.is_num()) {
@ -146,7 +146,7 @@ var builtin_id(context* ctx, gc* ngc) {
var builtin_int(context* ctx, gc* ngc) { var builtin_int(context* ctx, gc* ngc) {
auto val = ctx->localr[1]; auto val = ctx->localr[1];
if (val.type!=vm_type::vm_num && val.type!=vm_type::vm_str) { if (!val.is_num() && !val.is_str()) {
return nil; return nil;
} }
return var::num(static_cast<f64>(static_cast<i32>(val.to_num()))); return var::num(static_cast<f64>(static_cast<i32>(val.to_num())));
@ -167,7 +167,7 @@ var builtin_num(context* ctx, gc* ngc) {
if (val.is_num()) { if (val.is_num()) {
return val; return val;
} }
if (val.type!=vm_type::vm_str) { if (!val.is_str()) {
return nil; return nil;
} }
auto res = val.to_num(); auto res = val.to_num();
@ -179,7 +179,7 @@ var builtin_num(context* ctx, gc* ngc) {
var builtin_pop(context* ctx, gc* ngc) { var builtin_pop(context* ctx, gc* ngc) {
auto val = ctx->localr[1]; auto val = ctx->localr[1];
if (val.type!=vm_type::vm_vec) { if (!val.is_vec()) {
return nas_err("pop", "\"vec\" must be vector"); return nas_err("pop", "\"vec\" must be vector");
} }
auto& vec = val.vec().elems; auto& vec = val.vec().elems;
@ -204,13 +204,14 @@ var builtin_size(context* ctx, gc* ngc) {
case vm_type::vm_vec: num = val.vec().size(); break; case vm_type::vm_vec: num = val.vec().size(); break;
case vm_type::vm_hash: num = val.hash().size(); break; case vm_type::vm_hash: num = val.hash().size(); break;
case vm_type::vm_map: num = val.map().mapper.size(); break; case vm_type::vm_map: num = val.map().mapper.size(); break;
default: break;
} }
return var::num(num); return var::num(num);
} }
var builtin_time(context* ctx, gc* ngc) { var builtin_time(context* ctx, gc* ngc) {
auto val = ctx->localr[1]; auto val = ctx->localr[1];
if (val.type!=vm_type::vm_num) { if (!val.is_num()) {
return nas_err("time", "\"begin\" must be number"); return nas_err("time", "\"begin\" must be number");
} }
auto begin = static_cast<time_t>(val.num()); auto begin = static_cast<time_t>(val.num());
@ -221,7 +222,7 @@ var builtin_contains(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
var hash = local[1]; var hash = local[1];
var key = local[2]; var key = local[2];
if (hash.type!=vm_type::vm_hash || key.type!=vm_type::vm_str) { if (!hash.is_hash() || !key.is_str()) {
return zero; return zero;
} }
return hash.hash().elems.count(key.str())? one:zero; return hash.hash().elems.count(key.str())? one:zero;
@ -231,10 +232,10 @@ var builtin_delete(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
var hash = local[1]; var hash = local[1];
var key = local[2]; var key = local[2];
if (hash.type!=vm_type::vm_hash) { if (!hash.is_hash()) {
return nas_err("delete", "\"hash\" must be hash"); return nas_err("delete", "\"hash\" must be hash");
} }
if (key.type!=vm_type::vm_str) { if (!key.is_str()) {
return nil; return nil;
} }
if (hash.hash().elems.count(key.str())) { if (hash.hash().elems.count(key.str())) {
@ -245,7 +246,7 @@ var builtin_delete(context* ctx, gc* ngc) {
var builtin_keys(context* ctx, gc* ngc) { var builtin_keys(context* ctx, gc* ngc) {
auto hash = ctx->localr[1]; auto hash = ctx->localr[1];
if (hash.type!=vm_type::vm_hash && hash.type!=vm_type::vm_map) { if (!hash.is_hash() && !hash.is_map()) {
return nas_err("keys", "\"hash\" must be hash"); return nas_err("keys", "\"hash\" must be hash");
} }
// avoid being sweeped // avoid being sweeped
@ -291,6 +292,7 @@ var builtin_type(context* ctx, gc* ngc) {
case vm_type::vm_ghost: return ngc->newstr("ghost"); case vm_type::vm_ghost: return ngc->newstr("ghost");
case vm_type::vm_co: return ngc->newstr("coroutine"); case vm_type::vm_co: return ngc->newstr("coroutine");
case vm_type::vm_map: return ngc->newstr("namespace"); case vm_type::vm_map: return ngc->newstr("namespace");
default: break;
} }
return nil; return nil;
} }
@ -300,13 +302,13 @@ var builtin_substr(context* ctx, gc* ngc) {
var str = local[1]; var str = local[1];
var beg = local[2]; var beg = local[2];
var len = local[3]; var len = local[3];
if (str.type!=vm_type::vm_str) { if (!str.is_str()) {
return nas_err("substr", "\"str\" must be string"); return nas_err("substr", "\"str\" must be string");
} }
if (beg.type!=vm_type::vm_num || beg.num()<0) { if (!beg.is_num() || beg.num()<0) {
return nas_err("substr", "\"begin\" should be number >= 0"); return nas_err("substr", "\"begin\" should be number >= 0");
} }
if (len.type!=vm_type::vm_num || len.num()<0) { if (!len.is_num() || len.num()<0) {
return nas_err("substr", "\"length\" should be number >= 0"); return nas_err("substr", "\"length\" should be number >= 0");
} }
auto begin = static_cast<usize>(beg.num()); auto begin = static_cast<usize>(beg.num());
@ -322,7 +324,7 @@ var builtin_streq(context* ctx, gc* ngc) {
var a = local[1]; var a = local[1];
var b = local[2]; var b = local[2];
return var::num(static_cast<f64>( return var::num(static_cast<f64>(
(a.type!=vm_type::vm_str || b.type!=vm_type::vm_str)? 0:(a.str()==b.str()) (!a.is_str() || !b.is_str())? 0:(a.str()==b.str())
)); ));
} }
@ -330,10 +332,10 @@ var builtin_left(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
var str = local[1]; var str = local[1];
var len = local[2]; var len = local[2];
if (str.type!=vm_type::vm_str) { if (!str.is_str()) {
return nas_err("left", "\"string\" must be string"); return nas_err("left", "\"string\" must be string");
} }
if (len.type!=vm_type::vm_num) { if (!len.is_num()) {
return nas_err("left", "\"length\" must be number"); return nas_err("left", "\"length\" must be number");
} }
if (len.num()<0) { if (len.num()<0) {
@ -346,10 +348,10 @@ var builtin_right(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
var str = local[1]; var str = local[1];
var len = local[2]; var len = local[2];
if (str.type!=vm_type::vm_str) { if (!str.is_str()) {
return nas_err("right", "\"string\" must be string"); return nas_err("right", "\"string\" must be string");
} }
if (len.type!=vm_type::vm_num) { if (!len.is_num()) {
return nas_err("right", "\"length\" must be number"); return nas_err("right", "\"length\" must be number");
} }
i32 length = static_cast<i32>(len.num()); i32 length = static_cast<i32>(len.num());
@ -367,7 +369,7 @@ var builtin_cmp(context* ctx, gc* ngc) {
auto local = ctx->localr; auto local = ctx->localr;
var a = local[1]; var a = local[1];
var b = local[2]; var b = local[2];
if (a.type!=vm_type::vm_str || b.type!=vm_type::vm_str) { if (!a.is_str() || !b.is_str()) {
return nas_err("cmp", "\"a\" and \"b\" must be string"); return nas_err("cmp", "\"a\" and \"b\" must be string");
} }
return var::num(static_cast<f64>(strcmp( return var::num(static_cast<f64>(strcmp(
@ -410,7 +412,7 @@ var builtin_char(context* ctx, gc* ngc) {
var builtin_values(context* ctx, gc* ngc) { var builtin_values(context* ctx, gc* ngc) {
auto hash = ctx->localr[1]; auto hash = ctx->localr[1];
if (hash.type!=vm_type::vm_hash && hash.type!=vm_type::vm_map) { if (!hash.is_hash() && !hash.is_map()) {
return nas_err("values", "\"hash\" must be hash or namespace"); return nas_err("values", "\"hash\" must be hash or namespace");
} }
auto vec = ngc->alloc(vm_type::vm_vec); auto vec = ngc->alloc(vm_type::vm_vec);
@ -429,7 +431,7 @@ var builtin_values(context* ctx, gc* ngc) {
var builtin_sleep(context* ctx, gc* ngc) { var builtin_sleep(context* ctx, gc* ngc) {
auto val = ctx->localr[1]; auto val = ctx->localr[1];
if (val.type!=vm_type::vm_num) { if (!val.is_num()) {
return nil; return nil;
} }
#if defined(_WIN32) && !defined(_GLIBCXX_HAS_GTHREADS) #if defined(_WIN32) && !defined(_GLIBCXX_HAS_GTHREADS)
@ -561,7 +563,7 @@ std::string md5(const std::string& src) {
var builtin_md5(context* ctx, gc* ngc) { var builtin_md5(context* ctx, gc* ngc) {
auto str = ctx->localr[1]; auto str = ctx->localr[1];
if (str.type!=vm_type::vm_str) { if (!str.is_str()) {
return nas_err("md5", "\"str\" must be string"); return nas_err("md5", "\"str\" must be string");
} }
return ngc->newstr(md5(str.str())); return ngc->newstr(md5(str.str()));
@ -576,7 +578,7 @@ var builtin_millisec(context* ctx, gc* ngc) {
var builtin_gcextend(context* ctx, gc* ngc) { var builtin_gcextend(context* ctx, gc* ngc) {
auto type = ctx->localr[1]; auto type = ctx->localr[1];
if (type.type!=vm_type::vm_str) { if (!type.is_str()) {
return nil; return nil;
} }
const auto& s = type.str(); const auto& s = type.str();

16
src/nasal_type.cpp
View File

@ -42,16 +42,16 @@ var nas_hash::get_value(const std::string& key) {
} else if (!elems.count("parents")) { } else if (!elems.count("parents")) {
return var::none(); return var::none();
} }
var ret = var::none(); auto ret = var::none();
var val = elems.at("parents"); auto& val = elems.at("parents");
if (val.type!=vm_type::vm_vec) { if (!val.is_vec()) {
return ret; return ret;
} }
for(auto& i : val.vec().elems) { for(auto& i : val.vec().elems) {
if (i.is_hash()) { if (i.is_hash()) {
ret = i.hash().get_value(key); ret = i.hash().get_value(key);
} }
if (ret.type!=vm_type::vm_none) { if (!ret.is_none()) {
return ret; return ret;
} }
} }
@ -65,8 +65,8 @@ var* nas_hash::get_memory(const std::string& key) {
return nullptr; return nullptr;
} }
var* addr = nullptr; var* addr = nullptr;
var val = elems.at("parents"); var& val = elems.at("parents");
if (val.type!=vm_type::vm_vec) { if (!val.is_vec()) {
return addr; return addr;
} }
for(auto& i : val.vec().elems) { for(auto& i : val.vec().elems) {
@ -208,6 +208,7 @@ nas_val::nas_val(vm_type val_type) {
case vm_type::vm_ghost: ptr.obj = new nas_ghost; break; case vm_type::vm_ghost: ptr.obj = new nas_ghost; break;
case vm_type::vm_co: ptr.co = new nas_co; break; case vm_type::vm_co: ptr.co = new nas_co; break;
case vm_type::vm_map: ptr.map = new nas_map; break; case vm_type::vm_map: ptr.map = new nas_map; break;
default: break;
} }
} }
@ -221,6 +222,7 @@ nas_val::~nas_val() {
case vm_type::vm_ghost:delete ptr.obj; break; case vm_type::vm_ghost:delete ptr.obj; break;
case vm_type::vm_co: delete ptr.co; break; case vm_type::vm_co: delete ptr.co; break;
case vm_type::vm_map: delete ptr.map; break; case vm_type::vm_map: delete ptr.map; break;
default: break;
} }
type = vm_type::vm_nil; type = vm_type::vm_nil;
} }
@ -235,6 +237,7 @@ void nas_val::clear() {
case vm_type::vm_ghost:ptr.obj->clear(); break; case vm_type::vm_ghost:ptr.obj->clear(); break;
case vm_type::vm_co: ptr.co->clear(); break; case vm_type::vm_co: ptr.co->clear(); break;
case vm_type::vm_map: ptr.map->clear(); break; case vm_type::vm_map: ptr.map->clear(); break;
default: break;
} }
} }
@ -266,6 +269,7 @@ std::ostream& operator<<(std::ostream& out, var& ref) {
case vm_type::vm_ghost:out << ref.ghost(); break; case vm_type::vm_ghost:out << ref.ghost(); break;
case vm_type::vm_co: out << ref.co(); break; case vm_type::vm_co: out << ref.co(); break;
case vm_type::vm_map: out << ref.map(); break; case vm_type::vm_map: out << ref.map(); break;
default: break;
} }
return out; return out;
} }

1
src/nasal_vm.cpp
View File

@ -381,6 +381,7 @@ std::string vm::type_name_string(const var& value) const {
case vm_type::vm_ghost: return "ghost type"; case vm_type::vm_ghost: return "ghost type";
case vm_type::vm_co: return "coroutine"; case vm_type::vm_co: return "coroutine";
case vm_type::vm_map: return "namespace"; case vm_type::vm_map: return "namespace";
default: break;
} }
return "unknown"; return "unknown";
} }

26
src/nasal_vm.h
View File

@ -503,7 +503,7 @@ inline void vm::o_eq() {
} else if (val1.is_str() && val2.is_str()) { } else if (val1.is_str() && val2.is_str()) {
ctx.top[0] = (val1.str()==val2.str())? one:zero; ctx.top[0] = (val1.str()==val2.str())? one:zero;
} else if ((val1.is_num() || val2.is_num()) } else if ((val1.is_num() || val2.is_num())
&& val1.type!=vm_type::vm_nil && val2.type!=vm_type::vm_nil) { && !val1.is_nil() && !val2.is_nil()) {
ctx.top[0] = (val1.to_num()==val2.to_num())? one:zero; ctx.top[0] = (val1.to_num()==val2.to_num())? one:zero;
} else { } else {
ctx.top[0] = (val1==val2)? one:zero; ctx.top[0] = (val1==val2)? one:zero;
@ -518,7 +518,7 @@ inline void vm::o_neq() {
} else if (val1.is_str() && val2.is_str()) { } else if (val1.is_str() && val2.is_str()) {
ctx.top[0] = (val1.str()!=val2.str())? one:zero; ctx.top[0] = (val1.str()!=val2.str())? one:zero;
} else if ((val1.is_num() || val2.is_num()) } else if ((val1.is_num() || val2.is_num())
&& val1.type!=vm_type::vm_nil && val2.type!=vm_type::vm_nil) { && !val1.is_nil() && !val2.is_nil()) {
ctx.top[0] = (val1.to_num()!=val2.to_num())? one:zero; ctx.top[0] = (val1.to_num()!=val2.to_num())? one:zero;
} else { } else {
ctx.top[0] = (val1!=val2)? one:zero; ctx.top[0] = (val1!=val2)? one:zero;
@ -567,7 +567,7 @@ inline void vm::o_jf() {
} }
inline void vm::o_cnt() { inline void vm::o_cnt() {
if (ctx.top[0].type!=vm_type::vm_vec) { if (!ctx.top[0].is_vec()) {
die("must use vector in forindex/foreach but get "+ die("must use vector in forindex/foreach but get "+
type_name_string(ctx.top[0]) type_name_string(ctx.top[0])
); );
@ -620,7 +620,7 @@ inline void vm::o_callv() {
return; return;
} }
} else if (vec.is_hash()) { } else if (vec.is_hash()) {
if (val.type!=vm_type::vm_str) { if (!val.is_str()) {
die("must use string as the key but get "+type_name_string(val)); die("must use string as the key but get "+type_name_string(val));
return; return;
} }
@ -643,7 +643,7 @@ inline void vm::o_callv() {
static_cast<f64>(static_cast<u8>(str[num>=0? num:num+len])) static_cast<f64>(static_cast<u8>(str[num>=0? num:num+len]))
); );
} else if (vec.is_map()) { } else if (vec.is_map()) {
if (val.type!=vm_type::vm_str) { if (!val.is_str()) {
die("must use string as the key but get "+type_name_string(val)); die("must use string as the key but get "+type_name_string(val));
return; return;
} }
@ -660,7 +660,7 @@ inline void vm::o_callv() {
inline void vm::o_callvi() { inline void vm::o_callvi() {
var val = ctx.top[0]; var val = ctx.top[0];
if (val.type!=vm_type::vm_vec) { if (!val.is_vec()) {
die("must use a vector but get "+type_name_string(val)); die("must use a vector but get "+type_name_string(val));
return; return;
} }
@ -674,7 +674,7 @@ inline void vm::o_callvi() {
inline void vm::o_callh() { inline void vm::o_callh() {
var val = ctx.top[0]; var val = ctx.top[0];
if (val.type!=vm_type::vm_hash && val.type!=vm_type::vm_map) { if (!val.is_hash() && !val.is_map()) {
die("must call a hash but get "+type_name_string(val)); die("must call a hash but get "+type_name_string(val));
return; return;
} }
@ -697,7 +697,7 @@ inline void vm::o_callh() {
inline void vm::o_callfv() { inline void vm::o_callfv() {
const u32 argc = imm[ctx.pc]; // arguments counter const u32 argc = imm[ctx.pc]; // arguments counter
var* local = ctx.top-argc+1; // arguments begin address var* local = ctx.top-argc+1; // arguments begin address
if (local[-1].type!=vm_type::vm_func) { if (!local[-1].is_func()) {
die("must call a function but get "+type_name_string(local[-1])); die("must call a function but get "+type_name_string(local[-1]));
return; return;
} }
@ -766,7 +766,7 @@ inline void vm::o_callfv() {
inline void vm::o_callfh() { inline void vm::o_callfh() {
const auto& hash = ctx.top[0].hash().elems; const auto& hash = ctx.top[0].hash().elems;
if (ctx.top[-1].type!=vm_type::vm_func) { if (!ctx.top[-1].is_func()) {
die("must call a function but get "+type_name_string(ctx.top[-1])); die("must call a function but get "+type_name_string(ctx.top[-1]));
return; return;
} }
@ -844,7 +844,7 @@ inline void vm::o_slcbeg() {
// | resource_vec | <-- top[-1] // | resource_vec | <-- top[-1]
// +--------------+ // +--------------+
(++ctx.top)[0] = ngc.alloc(vm_type::vm_vec); (++ctx.top)[0] = ngc.alloc(vm_type::vm_vec);
if (ctx.top[-1].type!=vm_type::vm_vec) { if (!ctx.top[-1].is_vec()) {
die("must slice a vector but get "+type_name_string(ctx.top[-1])); die("must slice a vector but get "+type_name_string(ctx.top[-1]));
return; return;
} }
@ -933,7 +933,7 @@ inline void vm::o_mcallv() {
return; return;
} }
} else if (vec.is_hash()) { // do mcallh but use the mcallv way } else if (vec.is_hash()) { // do mcallh but use the mcallv way
if (val.type!=vm_type::vm_str) { if (!val.is_str()) {
die("must use string as the key but get "+type_name_string(val)); die("must use string as the key but get "+type_name_string(val));
return; return;
} }
@ -945,7 +945,7 @@ inline void vm::o_mcallv() {
ctx.memr = ref.get_memory(str); ctx.memr = ref.get_memory(str);
} }
} else if (vec.is_map()) { } else if (vec.is_map()) {
if (val.type!=vm_type::vm_str) { if (!val.is_str()) {
die("must use string as the key but get "+type_name_string(val)); die("must use string as the key but get "+type_name_string(val));
return; return;
} }
@ -963,7 +963,7 @@ inline void vm::o_mcallv() {
inline void vm::o_mcallh() { inline void vm::o_mcallh() {
var hash = ctx.top[0]; // mcall hash, reserved on stack to avoid gc var hash = ctx.top[0]; // mcall hash, reserved on stack to avoid gc
if (hash.type!=vm_type::vm_hash && hash.type!=vm_type::vm_map) { if (!hash.is_hash() && !hash.is_map()) {
die("must call a hash/namespace but get "+type_name_string(hash)); die("must call a hash/namespace but get "+type_name_string(hash));
return; return;
} }