mirror of
https://github.com/ValKmjolnir/Nasal-Interpreter.git
synced 2026-05-02 19:00:47 +08:00
ValKmjolnir
2344
src/nasal_parse.cpp
2344
src/nasal_parse.cpp
File diff suppressed because it is too large
Load Diff
@@ -1,169 +1,169 @@
|
||||
#pragma once
|
||||
|
||||
#include <unordered_map>
|
||||
|
||||
#include "nasal.h"
|
||||
#include "nasal_ast.h"
|
||||
#include "nasal_lexer.h"
|
||||
#include "nasal_err.h"
|
||||
|
||||
namespace nasal {
|
||||
|
||||
class parse {
|
||||
|
||||
#define thisspan (toks[ptr].loc)
|
||||
#define prevspan (ptr!=0? toks[ptr-1].loc:toks[ptr].loc)
|
||||
|
||||
private:
|
||||
u64 ptr;
|
||||
u64 in_func_depth; // count function block
|
||||
u64 in_loop_depth; // count loop block
|
||||
const token* toks;
|
||||
code_block* root;
|
||||
error err;
|
||||
|
||||
private:
|
||||
const std::unordered_map<tok, std::string> token_name_mapper = {
|
||||
{tok::tk_true , "true" },
|
||||
{tok::tk_false , "false" },
|
||||
{tok::tk_use , "use" },
|
||||
{tok::tk_for , "for" },
|
||||
{tok::tk_forindex, "forindex"},
|
||||
{tok::tk_foreach , "foreach" },
|
||||
{tok::tk_while , "while" },
|
||||
{tok::tk_var , "var" },
|
||||
{tok::tk_func , "func" },
|
||||
{tok::tk_brk , "break" },
|
||||
{tok::tk_cont , "continue"},
|
||||
{tok::tk_ret , "return" },
|
||||
{tok::tk_if , "if" },
|
||||
{tok::tk_elsif , "elsif" },
|
||||
{tok::tk_else , "else" },
|
||||
{tok::tk_nil , "nil" },
|
||||
{tok::tk_lcurve , "(" },
|
||||
{tok::tk_rcurve , ")" },
|
||||
{tok::tk_lbracket, "[" },
|
||||
{tok::tk_rbracket, "]" },
|
||||
{tok::tk_lbrace , "{" },
|
||||
{tok::tk_rbrace , "}" },
|
||||
{tok::tk_semi , ";" },
|
||||
{tok::tk_and , "and" },
|
||||
{tok::tk_or , "or" },
|
||||
{tok::tk_comma , "," },
|
||||
{tok::tk_dot , "." },
|
||||
{tok::tk_ellipsis, "..." },
|
||||
{tok::tk_quesmark, "?" },
|
||||
{tok::tk_quesques, "??" },
|
||||
{tok::tk_quesdot , "?." },
|
||||
{tok::tk_colon , ":" },
|
||||
{tok::tk_add , "+" },
|
||||
{tok::tk_sub , "-" },
|
||||
{tok::tk_mult , "*" },
|
||||
{tok::tk_div , "/" },
|
||||
{tok::tk_floater , "~" },
|
||||
{tok::tk_btand , "&" },
|
||||
{tok::tk_btor , "|" },
|
||||
{tok::tk_btxor , "^" },
|
||||
{tok::tk_not , "!" },
|
||||
{tok::tk_eq , "=" },
|
||||
{tok::tk_addeq , "+=" },
|
||||
{tok::tk_subeq , "-=" },
|
||||
{tok::tk_multeq , "*=" },
|
||||
{tok::tk_diveq , "/=" },
|
||||
{tok::tk_lnkeq , "~=" },
|
||||
{tok::tk_btandeq , "&=" },
|
||||
{tok::tk_btoreq , "|=" },
|
||||
{tok::tk_btxoreq , "^=" },
|
||||
{tok::tk_cmpeq , "==" },
|
||||
{tok::tk_neq , "!=" },
|
||||
{tok::tk_less , "<" },
|
||||
{tok::tk_leq , "<=" },
|
||||
{tok::tk_grt , ">" },
|
||||
{tok::tk_geq , ">=" }
|
||||
};
|
||||
|
||||
private:
|
||||
void die(const span&, const std::string&);
|
||||
void next();
|
||||
void match(tok, const char* info = nullptr);
|
||||
bool lookahead(tok);
|
||||
bool lookahead_expression();
|
||||
bool is_call(tok);
|
||||
bool check_comma(const tok*);
|
||||
bool check_tuple();
|
||||
bool check_func_end(expr*);
|
||||
bool check_in_curve_multi_definition();
|
||||
bool check_special_call();
|
||||
bool need_semi_check(expr*);
|
||||
void update_location(expr*);
|
||||
|
||||
private:
|
||||
use_stmt* use_stmt_gen();
|
||||
null_expr* null();
|
||||
nil_expr* nil();
|
||||
number_literal* num();
|
||||
string_literal* str();
|
||||
identifier* id();
|
||||
bool_literal* bools();
|
||||
vector_expr* vec();
|
||||
hash_expr* hash();
|
||||
hash_pair* pair();
|
||||
function* func();
|
||||
void params(function*);
|
||||
expr* lcurve_expr();
|
||||
expr* expression();
|
||||
code_block* expression_block();
|
||||
expr* calc();
|
||||
expr* bitwise_or();
|
||||
expr* bitwise_xor();
|
||||
expr* bitwise_and();
|
||||
expr* or_expr();
|
||||
expr* and_expr();
|
||||
expr* cmp_expr();
|
||||
expr* null_chain_expr();
|
||||
expr* additive_expr();
|
||||
expr* multive_expr();
|
||||
unary_operator* unary();
|
||||
expr* scalar();
|
||||
call* call_scalar();
|
||||
call_hash* callh();
|
||||
null_access* null_access_call();
|
||||
call_vector* callv();
|
||||
call_function* callf();
|
||||
slice_vector* subvec();
|
||||
expr* definition();
|
||||
multi_identifier* incurve_def();
|
||||
multi_identifier* outcurve_def();
|
||||
multi_identifier* multi_id();
|
||||
tuple_expr* multi_scalar();
|
||||
multi_assign* multi_assignment();
|
||||
expr* loop();
|
||||
while_expr* while_loop();
|
||||
for_expr* for_loop();
|
||||
forei_expr* forei_loop();
|
||||
iter_expr* iter_gen();
|
||||
condition_expr* cond();
|
||||
continue_expr* continue_expression();
|
||||
break_expr* break_expression();
|
||||
return_expr* return_expression();
|
||||
|
||||
public:
|
||||
code_block* tree() {return root;}
|
||||
|
||||
// swap root pointer with another pointer(maybe nullptr)
|
||||
code_block* swap(code_block* another) {
|
||||
auto res = root;
|
||||
root = another;
|
||||
return res;
|
||||
}
|
||||
|
||||
public:
|
||||
parse(): ptr(0), in_func_depth(0),
|
||||
in_loop_depth(0), toks(nullptr),
|
||||
root(nullptr) {}
|
||||
~parse() {delete root;}
|
||||
const error& compile(const lexer&);
|
||||
static void easter_egg();
|
||||
};
|
||||
|
||||
}
|
||||
#pragma once
|
||||
|
||||
#include <unordered_map>
|
||||
|
||||
#include "nasal.h"
|
||||
#include "nasal_ast.h"
|
||||
#include "nasal_lexer.h"
|
||||
#include "nasal_err.h"
|
||||
|
||||
namespace nasal {
|
||||
|
||||
class parse {
|
||||
|
||||
#define thisspan (toks[ptr].loc)
|
||||
#define prevspan (ptr!=0? toks[ptr-1].loc:toks[ptr].loc)
|
||||
|
||||
private:
|
||||
u64 ptr;
|
||||
u64 in_func_depth; // count function block
|
||||
u64 in_loop_depth; // count loop block
|
||||
const token* toks;
|
||||
code_block* root;
|
||||
error err;
|
||||
|
||||
private:
|
||||
const std::unordered_map<tok, std::string> token_name_mapper = {
|
||||
{tok::tk_true , "true" },
|
||||
{tok::tk_false , "false" },
|
||||
{tok::tk_use , "use" },
|
||||
{tok::tk_for , "for" },
|
||||
{tok::tk_forindex, "forindex"},
|
||||
{tok::tk_foreach , "foreach" },
|
||||
{tok::tk_while , "while" },
|
||||
{tok::tk_var , "var" },
|
||||
{tok::tk_func , "func" },
|
||||
{tok::tk_brk , "break" },
|
||||
{tok::tk_cont , "continue"},
|
||||
{tok::tk_ret , "return" },
|
||||
{tok::tk_if , "if" },
|
||||
{tok::tk_elsif , "elsif" },
|
||||
{tok::tk_else , "else" },
|
||||
{tok::tk_nil , "nil" },
|
||||
{tok::tk_lcurve , "(" },
|
||||
{tok::tk_rcurve , ")" },
|
||||
{tok::tk_lbracket, "[" },
|
||||
{tok::tk_rbracket, "]" },
|
||||
{tok::tk_lbrace , "{" },
|
||||
{tok::tk_rbrace , "}" },
|
||||
{tok::tk_semi , ";" },
|
||||
{tok::tk_and , "and" },
|
||||
{tok::tk_or , "or" },
|
||||
{tok::tk_comma , "," },
|
||||
{tok::tk_dot , "." },
|
||||
{tok::tk_ellipsis, "..." },
|
||||
{tok::tk_quesmark, "?" },
|
||||
{tok::tk_quesques, "??" },
|
||||
{tok::tk_quesdot , "?." },
|
||||
{tok::tk_colon , ":" },
|
||||
{tok::tk_add , "+" },
|
||||
{tok::tk_sub , "-" },
|
||||
{tok::tk_mult , "*" },
|
||||
{tok::tk_div , "/" },
|
||||
{tok::tk_floater , "~" },
|
||||
{tok::tk_btand , "&" },
|
||||
{tok::tk_btor , "|" },
|
||||
{tok::tk_btxor , "^" },
|
||||
{tok::tk_not , "!" },
|
||||
{tok::tk_eq , "=" },
|
||||
{tok::tk_addeq , "+=" },
|
||||
{tok::tk_subeq , "-=" },
|
||||
{tok::tk_multeq , "*=" },
|
||||
{tok::tk_diveq , "/=" },
|
||||
{tok::tk_lnkeq , "~=" },
|
||||
{tok::tk_btandeq , "&=" },
|
||||
{tok::tk_btoreq , "|=" },
|
||||
{tok::tk_btxoreq , "^=" },
|
||||
{tok::tk_cmpeq , "==" },
|
||||
{tok::tk_neq , "!=" },
|
||||
{tok::tk_less , "<" },
|
||||
{tok::tk_leq , "<=" },
|
||||
{tok::tk_grt , ">" },
|
||||
{tok::tk_geq , ">=" }
|
||||
};
|
||||
|
||||
private:
|
||||
void die(const span&, const std::string&);
|
||||
void next();
|
||||
void match(tok, const char* info = nullptr);
|
||||
bool lookahead(tok);
|
||||
bool lookahead_expression();
|
||||
bool is_call(tok);
|
||||
bool check_comma(const tok*);
|
||||
bool check_tuple();
|
||||
bool check_func_end(expr*);
|
||||
bool check_in_curve_multi_definition();
|
||||
bool check_special_call();
|
||||
bool need_semi_check(expr*);
|
||||
void update_location(expr*);
|
||||
|
||||
private:
|
||||
use_stmt* use_stmt_gen();
|
||||
null_expr* null();
|
||||
nil_expr* nil();
|
||||
number_literal* num();
|
||||
string_literal* str();
|
||||
identifier* id();
|
||||
bool_literal* bools();
|
||||
vector_expr* vec();
|
||||
hash_expr* hash();
|
||||
hash_pair* pair();
|
||||
function* func();
|
||||
void params(function*);
|
||||
expr* lcurve_expr();
|
||||
expr* expression();
|
||||
code_block* expression_block();
|
||||
expr* calc();
|
||||
expr* bitwise_or();
|
||||
expr* bitwise_xor();
|
||||
expr* bitwise_and();
|
||||
expr* or_expr();
|
||||
expr* and_expr();
|
||||
expr* cmp_expr();
|
||||
expr* null_chain_expr();
|
||||
expr* additive_expr();
|
||||
expr* multive_expr();
|
||||
unary_operator* unary();
|
||||
expr* scalar();
|
||||
call* call_scalar();
|
||||
call_hash* callh();
|
||||
null_access* null_access_call();
|
||||
call_vector* callv();
|
||||
call_function* callf();
|
||||
slice_vector* subvec();
|
||||
expr* definition();
|
||||
multi_identifier* incurve_def();
|
||||
multi_identifier* outcurve_def();
|
||||
multi_identifier* multi_id();
|
||||
tuple_expr* multi_scalar();
|
||||
multi_assign* multi_assignment();
|
||||
expr* loop();
|
||||
while_expr* while_loop();
|
||||
for_expr* for_loop();
|
||||
forei_expr* forei_loop();
|
||||
iter_expr* iter_gen();
|
||||
condition_expr* cond();
|
||||
continue_expr* continue_expression();
|
||||
break_expr* break_expression();
|
||||
return_expr* return_expression();
|
||||
|
||||
public:
|
||||
code_block* tree() {return root;}
|
||||
|
||||
// swap root pointer with another pointer(maybe nullptr)
|
||||
code_block* swap(code_block* another) {
|
||||
auto res = root;
|
||||
root = another;
|
||||
return res;
|
||||
}
|
||||
|
||||
public:
|
||||
parse(): ptr(0), in_func_depth(0),
|
||||
in_loop_depth(0), toks(nullptr),
|
||||
root(nullptr) {}
|
||||
~parse() {delete root;}
|
||||
const error& compile(const lexer&);
|
||||
static void easter_egg();
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
@@ -1,301 +1,281 @@
|
||||
#include "nasal_type.h"
|
||||
#include "util/util.h"
|
||||
|
||||
#include <cstring>
|
||||
#include <sstream>
|
||||
|
||||
namespace nasal {
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, nas_vec& vec) {
|
||||
if (!vec.elems.size() || vec.printed) {
|
||||
out << (vec.elems.size()? "[..]":"[]");
|
||||
return out;
|
||||
}
|
||||
vec.printed = true;
|
||||
usize iter = 0, size = vec.elems.size();
|
||||
out << "[";
|
||||
for (auto& i:vec.elems) {
|
||||
out << i << ",]"[(++iter)==size];
|
||||
}
|
||||
vec.printed = false;
|
||||
return out;
|
||||
}
|
||||
|
||||
var nas_hash::get_value(const std::string& key) {
|
||||
if (elems.count(key)) {
|
||||
return elems.at(key);
|
||||
}
|
||||
if (!elems.count("parents")) {
|
||||
return var::none();
|
||||
}
|
||||
|
||||
auto ret = var::none();
|
||||
auto& val = elems.at("parents");
|
||||
if (!val.is_vec()) {
|
||||
return ret;
|
||||
}
|
||||
for (auto& i : val.vec().elems) {
|
||||
if (i.is_hash()) {
|
||||
ret = i.hash().get_value(key);
|
||||
}
|
||||
if (!ret.is_none()) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
var* nas_hash::get_memory(const std::string& key) {
|
||||
if (elems.count(key)) {
|
||||
return &elems.at(key);
|
||||
}
|
||||
if (!elems.count("parents")) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
var* addr = nullptr;
|
||||
var& val = elems.at("parents");
|
||||
if (!val.is_vec()) {
|
||||
return addr;
|
||||
}
|
||||
for (auto& i : val.vec().elems) {
|
||||
// recursively search key in `parents`
|
||||
if (i.is_hash()) {
|
||||
addr = i.hash().get_memory(key);
|
||||
}
|
||||
if (addr) {
|
||||
return addr;
|
||||
}
|
||||
}
|
||||
return addr;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, nas_hash& hash) {
|
||||
if (!hash.elems.size() || hash.printed) {
|
||||
out << (hash.elems.size()? "{..}":"{}");
|
||||
return out;
|
||||
}
|
||||
|
||||
// mark print, to avoid infinite recursion
|
||||
hash.printed = true;
|
||||
|
||||
static const char* sep[] = {", ", "}"};
|
||||
usize iter = 0, size = hash.elems.size();
|
||||
out << "{";
|
||||
for (auto& i : hash.elems) {
|
||||
out << i.first << ": " << i.second << sep[(++iter)==size];
|
||||
}
|
||||
|
||||
// restore flag
|
||||
hash.printed = false;
|
||||
return out;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, nas_func& func) {
|
||||
out << "func(";
|
||||
|
||||
std::vector<std::string> argument_list = {};
|
||||
argument_list.resize(func.keys.size());
|
||||
for (const auto& key : func.keys) {
|
||||
argument_list[key.second-1] = key.first;
|
||||
}
|
||||
|
||||
for (const auto& key : argument_list) {
|
||||
out << key;
|
||||
if (key != argument_list.back()) {
|
||||
out << ", ";
|
||||
}
|
||||
}
|
||||
if (func.dynamic_parameter_index>=0) {
|
||||
out << (argument_list.size()? ", ":"");
|
||||
out << func.dynamic_parameter_name << "...";
|
||||
}
|
||||
|
||||
out << ") {..}";
|
||||
return out;
|
||||
}
|
||||
|
||||
void nas_func::clear() {
|
||||
dynamic_parameter_index = -1;
|
||||
local.clear();
|
||||
upval.clear();
|
||||
keys.clear();
|
||||
}
|
||||
|
||||
void nas_ghost::set(const std::string& ghost_type_name,
|
||||
destructor destructor_pointer,
|
||||
marker gc_marker_pointer,
|
||||
void* ghost_pointer) {
|
||||
type_name = ghost_type_name;
|
||||
destructor_function = destructor_pointer;
|
||||
gc_mark_function = gc_marker_pointer;
|
||||
pointer = ghost_pointer;
|
||||
}
|
||||
|
||||
void nas_ghost::clear() {
|
||||
// do nothing if pointer is null
|
||||
if (!pointer) {
|
||||
return;
|
||||
}
|
||||
|
||||
// do clear pointer if destructor function pointer is null
|
||||
if (!destructor_function) {
|
||||
type_name = "";
|
||||
pointer = nullptr;
|
||||
return;
|
||||
}
|
||||
|
||||
// do destruction
|
||||
destructor_function(pointer);
|
||||
type_name = "";
|
||||
pointer = nullptr;
|
||||
destructor_function = nullptr;
|
||||
gc_mark_function = nullptr;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, const nas_ghost& ghost) {
|
||||
out << "<" << ghost.get_ghost_name();
|
||||
out << "@0x" << std::hex << ghost.convert<u64>() << std::dec << ">";
|
||||
return out;
|
||||
}
|
||||
|
||||
void nas_co::clear() {
|
||||
if (!ctx.stack) {
|
||||
return;
|
||||
}
|
||||
for (u32 i = 0; i < VM_STACK_DEPTH; ++i) {
|
||||
ctx.stack[i] = var::nil();
|
||||
}
|
||||
|
||||
ctx.pc = 0;
|
||||
ctx.localr = nullptr;
|
||||
ctx.memr = nullptr;
|
||||
ctx.canary = ctx.stack+VM_STACK_DEPTH-1;
|
||||
ctx.top = ctx.stack;
|
||||
ctx.func_top = ctx.func_stack;
|
||||
ctx.funcr = var::nil();
|
||||
ctx.upvalr = var::nil();
|
||||
|
||||
status = status::suspended;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, const nas_co& co) {
|
||||
out << "<coroutine at 0x" << std::hex;
|
||||
out << reinterpret_cast<u64>(&co) << std::dec << ">";
|
||||
return out;
|
||||
}
|
||||
|
||||
var nas_map::get_value(const std::string& key) {
|
||||
if (mapper.count(key)) {
|
||||
return *mapper.at(key);
|
||||
}
|
||||
return var::none();
|
||||
}
|
||||
|
||||
var* nas_map::get_memory(const std::string& key) {
|
||||
if (mapper.count(key)) {
|
||||
return mapper.at(key);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, nas_map& mp) {
|
||||
if (!mp.mapper.size() || mp.printed) {
|
||||
out << (mp.mapper.size()? "{..}":"{}");
|
||||
return out;
|
||||
}
|
||||
|
||||
// mark print, to avoid infinite recursion
|
||||
mp.printed = true;
|
||||
|
||||
static const char* sep[] = {", ", "}"};
|
||||
usize iter = 0, size = mp.mapper.size();
|
||||
out << "{";
|
||||
for (auto& i : mp.mapper) {
|
||||
out << i.first << ": " << *i.second << sep[(++iter)==size];
|
||||
}
|
||||
|
||||
// restore flag
|
||||
mp.printed = false;
|
||||
return out;
|
||||
}
|
||||
|
||||
nas_val::nas_val(vm_type val_type) {
|
||||
mark = gc_status::collected;
|
||||
type = val_type;
|
||||
immutable = 0;
|
||||
switch(val_type) {
|
||||
case vm_type::vm_str: ptr.str = new std::string; break;
|
||||
case vm_type::vm_vec: ptr.vec = new nas_vec; break;
|
||||
case vm_type::vm_hash: ptr.hash = new nas_hash; break;
|
||||
case vm_type::vm_func: ptr.func = new nas_func; break;
|
||||
case vm_type::vm_upval: ptr.upval = new nas_upval; 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_map: ptr.map = new nas_map; break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
nas_val::~nas_val() {
|
||||
switch(type) {
|
||||
case vm_type::vm_str: delete ptr.str; break;
|
||||
case vm_type::vm_vec: delete ptr.vec; break;
|
||||
case vm_type::vm_hash: delete ptr.hash; break;
|
||||
case vm_type::vm_func: delete ptr.func; break;
|
||||
case vm_type::vm_upval: delete ptr.upval; break;
|
||||
case vm_type::vm_ghost: delete ptr.obj; break;
|
||||
case vm_type::vm_co: delete ptr.co; break;
|
||||
case vm_type::vm_map: delete ptr.map; break;
|
||||
default: break;
|
||||
}
|
||||
type = vm_type::vm_nil;
|
||||
}
|
||||
|
||||
void nas_val::clear() {
|
||||
switch(type) {
|
||||
case vm_type::vm_str: ptr.str->clear(); break;
|
||||
case vm_type::vm_vec: ptr.vec->elems.clear(); break;
|
||||
case vm_type::vm_hash: ptr.hash->elems.clear(); break;
|
||||
case vm_type::vm_func: ptr.func->clear(); break;
|
||||
case vm_type::vm_upval: ptr.upval->clear(); break;
|
||||
case vm_type::vm_ghost: ptr.obj->clear(); break;
|
||||
case vm_type::vm_co: ptr.co->clear(); break;
|
||||
case vm_type::vm_map: ptr.map->clear(); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
std::string var::to_str() {
|
||||
if (type==vm_type::vm_str) {
|
||||
return str();
|
||||
} else if (type==vm_type::vm_num) {
|
||||
auto tmp = std::to_string(num());
|
||||
tmp.erase(tmp.find_last_not_of('0') + 1, std::string::npos);
|
||||
tmp.erase(tmp.find_last_not_of('.') + 1, std::string::npos);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
std::stringstream ss;
|
||||
ss << *this;
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, var& ref) {
|
||||
switch(ref.type) {
|
||||
case vm_type::vm_none: out << "undefined"; break;
|
||||
case vm_type::vm_nil: out << "nil"; break;
|
||||
case vm_type::vm_num: out << ref.val.num; break;
|
||||
case vm_type::vm_str: out << ref.str(); break;
|
||||
case vm_type::vm_vec: out << ref.vec(); break;
|
||||
case vm_type::vm_hash: out << ref.hash(); break;
|
||||
case vm_type::vm_func: out << ref.func(); break;
|
||||
case vm_type::vm_ghost: out << ref.ghost(); break;
|
||||
case vm_type::vm_co: out << ref.co(); break;
|
||||
case vm_type::vm_map: out << ref.map(); break;
|
||||
default: break;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
#include "nasal_type.h"
|
||||
#include "util/util.h"
|
||||
|
||||
#include <cstring>
|
||||
#include <sstream>
|
||||
|
||||
namespace nasal {
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, nas_vec& vec) {
|
||||
if (!vec.elems.size() || vec.printed) {
|
||||
out << (vec.elems.size()? "[..]":"[]");
|
||||
return out;
|
||||
}
|
||||
vec.printed = true;
|
||||
usize iter = 0, size = vec.elems.size();
|
||||
out << "[";
|
||||
for (auto& i:vec.elems) {
|
||||
out << i << ",]"[(++iter)==size];
|
||||
}
|
||||
vec.printed = false;
|
||||
return out;
|
||||
}
|
||||
|
||||
var nas_hash::get_value(const std::string& key) {
|
||||
if (elems.count(key)) {
|
||||
return elems.at(key);
|
||||
}
|
||||
if (!elems.count("parents")) {
|
||||
return var::none();
|
||||
}
|
||||
|
||||
auto ret = var::none();
|
||||
auto& val = elems.at("parents");
|
||||
if (!val.is_vec()) {
|
||||
return ret;
|
||||
}
|
||||
for (auto& i : val.vec().elems) {
|
||||
if (i.is_hash()) {
|
||||
ret = i.hash().get_value(key);
|
||||
}
|
||||
if (!ret.is_none()) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
var* nas_hash::get_memory(const std::string& key) {
|
||||
if (elems.count(key)) {
|
||||
return &elems.at(key);
|
||||
}
|
||||
if (!elems.count("parents")) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
var* addr = nullptr;
|
||||
var& val = elems.at("parents");
|
||||
if (!val.is_vec()) {
|
||||
return addr;
|
||||
}
|
||||
for (auto& i : val.vec().elems) {
|
||||
// recursively search key in `parents`
|
||||
if (i.is_hash()) {
|
||||
addr = i.hash().get_memory(key);
|
||||
}
|
||||
if (addr) {
|
||||
return addr;
|
||||
}
|
||||
}
|
||||
return addr;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, nas_hash& hash) {
|
||||
if (!hash.elems.size() || hash.printed) {
|
||||
out << (hash.elems.size()? "{..}":"{}");
|
||||
return out;
|
||||
}
|
||||
|
||||
// mark print, to avoid infinite recursion
|
||||
hash.printed = true;
|
||||
|
||||
static const char* sep[] = {", ", "}"};
|
||||
usize iter = 0, size = hash.elems.size();
|
||||
out << "{";
|
||||
for (auto& i : hash.elems) {
|
||||
out << i.first << ": " << i.second << sep[(++iter)==size];
|
||||
}
|
||||
|
||||
// restore flag
|
||||
hash.printed = false;
|
||||
return out;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, nas_func& func) {
|
||||
out << "func(";
|
||||
|
||||
std::vector<std::string> argument_list = {};
|
||||
argument_list.resize(func.keys.size());
|
||||
for (const auto& key : func.keys) {
|
||||
argument_list[key.second-1] = key.first;
|
||||
}
|
||||
|
||||
for (const auto& key : argument_list) {
|
||||
out << key;
|
||||
if (key != argument_list.back()) {
|
||||
out << ", ";
|
||||
}
|
||||
}
|
||||
if (func.dynamic_parameter_index>=0) {
|
||||
out << (argument_list.size()? ", ":"");
|
||||
out << func.dynamic_parameter_name << "...";
|
||||
}
|
||||
|
||||
out << ") {..}";
|
||||
return out;
|
||||
}
|
||||
|
||||
void nas_func::clear() {
|
||||
dynamic_parameter_index = -1;
|
||||
local.clear();
|
||||
upval.clear();
|
||||
keys.clear();
|
||||
}
|
||||
|
||||
void nas_ghost::set(const std::string& ghost_type_name,
|
||||
destructor destructor_pointer,
|
||||
marker gc_marker_pointer,
|
||||
void* ghost_pointer) {
|
||||
type_name = ghost_type_name;
|
||||
destructor_function = destructor_pointer;
|
||||
gc_mark_function = gc_marker_pointer;
|
||||
pointer = ghost_pointer;
|
||||
}
|
||||
|
||||
void nas_ghost::clear() {
|
||||
// do nothing if pointer is null
|
||||
if (!pointer) {
|
||||
return;
|
||||
}
|
||||
|
||||
// do clear pointer if destructor function pointer is null
|
||||
if (!destructor_function) {
|
||||
type_name = "";
|
||||
pointer = nullptr;
|
||||
return;
|
||||
}
|
||||
|
||||
// do destruction
|
||||
destructor_function(pointer);
|
||||
type_name = "";
|
||||
pointer = nullptr;
|
||||
destructor_function = nullptr;
|
||||
gc_mark_function = nullptr;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, const nas_ghost& ghost) {
|
||||
out << "<" << ghost.get_ghost_name();
|
||||
out << "@0x" << std::hex << ghost.convert<u64>() << std::dec << ">";
|
||||
return out;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, const nas_co& co) {
|
||||
out << "<coroutine at 0x" << std::hex;
|
||||
out << reinterpret_cast<u64>(&co) << std::dec << ">";
|
||||
return out;
|
||||
}
|
||||
|
||||
var nas_map::get_value(const std::string& key) {
|
||||
if (mapper.count(key)) {
|
||||
return *mapper.at(key);
|
||||
}
|
||||
return var::none();
|
||||
}
|
||||
|
||||
var* nas_map::get_memory(const std::string& key) {
|
||||
if (mapper.count(key)) {
|
||||
return mapper.at(key);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, nas_map& mp) {
|
||||
if (!mp.mapper.size() || mp.printed) {
|
||||
out << (mp.mapper.size()? "{..}":"{}");
|
||||
return out;
|
||||
}
|
||||
|
||||
// mark print, to avoid infinite recursion
|
||||
mp.printed = true;
|
||||
|
||||
static const char* sep[] = {", ", "}"};
|
||||
usize iter = 0, size = mp.mapper.size();
|
||||
out << "{";
|
||||
for (auto& i : mp.mapper) {
|
||||
out << i.first << ": " << *i.second << sep[(++iter)==size];
|
||||
}
|
||||
|
||||
// restore flag
|
||||
mp.printed = false;
|
||||
return out;
|
||||
}
|
||||
|
||||
nas_val::nas_val(vm_type val_type) {
|
||||
mark = gc_status::collected;
|
||||
type = val_type;
|
||||
immutable = 0;
|
||||
switch(val_type) {
|
||||
case vm_type::vm_str: ptr.str = new std::string; break;
|
||||
case vm_type::vm_vec: ptr.vec = new nas_vec; break;
|
||||
case vm_type::vm_hash: ptr.hash = new nas_hash; break;
|
||||
case vm_type::vm_func: ptr.func = new nas_func; break;
|
||||
case vm_type::vm_upval: ptr.upval = new nas_upval; 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_map: ptr.map = new nas_map; break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
nas_val::~nas_val() {
|
||||
switch(type) {
|
||||
case vm_type::vm_str: delete ptr.str; break;
|
||||
case vm_type::vm_vec: delete ptr.vec; break;
|
||||
case vm_type::vm_hash: delete ptr.hash; break;
|
||||
case vm_type::vm_func: delete ptr.func; break;
|
||||
case vm_type::vm_upval: delete ptr.upval; break;
|
||||
case vm_type::vm_ghost: delete ptr.obj; break;
|
||||
case vm_type::vm_co: delete ptr.co; break;
|
||||
case vm_type::vm_map: delete ptr.map; break;
|
||||
default: break;
|
||||
}
|
||||
type = vm_type::vm_nil;
|
||||
}
|
||||
|
||||
void nas_val::clear() {
|
||||
switch(type) {
|
||||
case vm_type::vm_str: ptr.str->clear(); break;
|
||||
case vm_type::vm_vec: ptr.vec->elems.clear(); break;
|
||||
case vm_type::vm_hash: ptr.hash->elems.clear(); break;
|
||||
case vm_type::vm_func: ptr.func->clear(); break;
|
||||
case vm_type::vm_upval: ptr.upval->clear(); break;
|
||||
case vm_type::vm_ghost: ptr.obj->clear(); break;
|
||||
case vm_type::vm_co: ptr.co->clear(); break;
|
||||
case vm_type::vm_map: ptr.map->clear(); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
std::string var::to_str() {
|
||||
if (type==vm_type::vm_str) {
|
||||
return str();
|
||||
} else if (type==vm_type::vm_num) {
|
||||
auto tmp = std::to_string(num());
|
||||
tmp.erase(tmp.find_last_not_of('0') + 1, std::string::npos);
|
||||
tmp.erase(tmp.find_last_not_of('.') + 1, std::string::npos);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
std::stringstream ss;
|
||||
ss << *this;
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, var& ref) {
|
||||
switch(ref.type) {
|
||||
case vm_type::vm_none: out << "undefined"; break;
|
||||
case vm_type::vm_nil: out << "nil"; break;
|
||||
case vm_type::vm_num: out << ref.val.num; break;
|
||||
case vm_type::vm_str: out << ref.str(); break;
|
||||
case vm_type::vm_vec: out << ref.vec(); break;
|
||||
case vm_type::vm_hash: out << ref.hash(); break;
|
||||
case vm_type::vm_func: out << ref.func(); break;
|
||||
case vm_type::vm_ghost: out << ref.ghost(); break;
|
||||
case vm_type::vm_co: out << ref.co(); break;
|
||||
case vm_type::vm_map: out << ref.map(); break;
|
||||
default: break;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
}
|
||||
764
src/nasal_type.h
764
src/nasal_type.h
@@ -1,368 +1,398 @@
|
||||
#pragma once
|
||||
|
||||
#include "nasal.h"
|
||||
#include "util/util.h"
|
||||
|
||||
#include <cstring>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <unordered_map>
|
||||
|
||||
namespace nasal {
|
||||
|
||||
enum class vm_type: u8 {
|
||||
/* none-gc object */
|
||||
vm_none = 0, // error type
|
||||
vm_cnt, // counter for forindex/foreach loop
|
||||
vm_addr, // var* address
|
||||
vm_ret, // return addres(program counter)
|
||||
vm_nil, // nil
|
||||
vm_num, // number
|
||||
|
||||
/* gc object */
|
||||
vm_str, // string
|
||||
vm_vec, // vector
|
||||
vm_hash, // hashmap(dict)
|
||||
vm_func, // function(lambda)
|
||||
vm_upval, // upvalue
|
||||
vm_ghost, // ghost type
|
||||
vm_co, // coroutine
|
||||
vm_map, // for globals and namespaces
|
||||
|
||||
/* mark type range */
|
||||
vm_type_size_max
|
||||
};
|
||||
|
||||
// size of gc object type
|
||||
const u32 GC_TYPE_SIZE =
|
||||
static_cast<u32>(vm_type::vm_type_size_max) -
|
||||
static_cast<u32>(vm_type::vm_str);
|
||||
|
||||
// basic types
|
||||
struct nas_vec; // vector
|
||||
struct nas_hash; // hashmap(dict)
|
||||
struct nas_func; // function(lambda)
|
||||
struct nas_upval; // upvalue
|
||||
struct nas_ghost; // objects
|
||||
struct nas_co; // coroutine
|
||||
struct nas_map; // mapper
|
||||
|
||||
// nas_val includes gc-managed types
|
||||
struct nas_val {
|
||||
enum class gc_status: u8 {
|
||||
uncollected = 0,
|
||||
collected,
|
||||
found
|
||||
};
|
||||
|
||||
gc_status mark;
|
||||
vm_type type; // value type
|
||||
u8 immutable; // used to mark if a string is immutable
|
||||
union elem {
|
||||
std::string* str;
|
||||
nas_vec* vec;
|
||||
nas_hash* hash;
|
||||
nas_func* func;
|
||||
nas_upval* upval;
|
||||
nas_ghost* obj;
|
||||
nas_co* co;
|
||||
nas_map* map;
|
||||
} ptr;
|
||||
|
||||
nas_val(vm_type);
|
||||
~nas_val();
|
||||
void clear();
|
||||
};
|
||||
|
||||
struct var {
|
||||
public:
|
||||
vm_type type = vm_type::vm_none;
|
||||
union {
|
||||
u64 ret;
|
||||
i64 cnt;
|
||||
f64 num;
|
||||
var* addr;
|
||||
nas_val* gcobj;
|
||||
} val;
|
||||
|
||||
private:
|
||||
var(vm_type t, u64 pc) { type = t; val.ret = pc; }
|
||||
var(vm_type t, i64 ct) { type = t; val.cnt = ct; }
|
||||
var(vm_type t, f64 n) { type = t; val.num = n; }
|
||||
var(vm_type t, var* p) { type = t; val.addr = p; }
|
||||
var(vm_type t, nas_val* p) { type = t; val.gcobj = p; }
|
||||
|
||||
public:
|
||||
var() = default;
|
||||
var(const var&) = default;
|
||||
bool operator==(const var& nr) const {
|
||||
return type == nr.type && val.gcobj == nr.val.gcobj;
|
||||
}
|
||||
bool operator!=(const var& nr) const {
|
||||
return type != nr.type || val.gcobj != nr.val.gcobj;
|
||||
}
|
||||
|
||||
public:
|
||||
// create new var object
|
||||
static var none() {
|
||||
return var(vm_type::vm_none, static_cast<u64>(0));
|
||||
}
|
||||
static var nil() {
|
||||
return var(vm_type::vm_nil, static_cast<u64>(0));
|
||||
}
|
||||
static var ret(u64 pc) {
|
||||
return var(vm_type::vm_ret, pc);
|
||||
}
|
||||
static var cnt(i64 n) {
|
||||
return var(vm_type::vm_cnt, n);
|
||||
}
|
||||
static var num(f64 n) {
|
||||
return var(vm_type::vm_num, n);
|
||||
}
|
||||
static var gcobj(nas_val* p) {
|
||||
return var(p->type, p);
|
||||
}
|
||||
static var addr(var* p) {
|
||||
return var(vm_type::vm_addr, p);
|
||||
}
|
||||
|
||||
public:
|
||||
// get value
|
||||
var* addr() const { return val.addr; }
|
||||
u64 ret() const { return val.ret; }
|
||||
i64& cnt() { return val.cnt; }
|
||||
f64 num() const { return val.num; }
|
||||
|
||||
public:
|
||||
// get gc object
|
||||
std::string& str() { return *val.gcobj->ptr.str; }
|
||||
nas_vec& vec() { return *val.gcobj->ptr.vec; }
|
||||
nas_hash& hash() { return *val.gcobj->ptr.hash; }
|
||||
nas_func& func() { return *val.gcobj->ptr.func; }
|
||||
nas_upval& upval() { return *val.gcobj->ptr.upval; }
|
||||
nas_ghost& ghost() { return *val.gcobj->ptr.obj; }
|
||||
nas_co& co() { return *val.gcobj->ptr.co; }
|
||||
nas_map& map() { return *val.gcobj->ptr.map; }
|
||||
|
||||
|
||||
public:
|
||||
// get const gc object
|
||||
const std::string& str() const { return *val.gcobj->ptr.str; }
|
||||
const nas_vec& vec() const { return *val.gcobj->ptr.vec; }
|
||||
const nas_hash& hash() const { return *val.gcobj->ptr.hash; }
|
||||
const nas_func& func() const { return *val.gcobj->ptr.func; }
|
||||
const nas_upval& upval() const { return *val.gcobj->ptr.upval; }
|
||||
const nas_ghost& ghost() const { return *val.gcobj->ptr.obj; }
|
||||
const nas_co& co() const { return *val.gcobj->ptr.co; }
|
||||
const nas_map& map() const { return *val.gcobj->ptr.map; }
|
||||
|
||||
public:
|
||||
bool is_none() const { return type == vm_type::vm_none; }
|
||||
bool is_cnt() const { return type == vm_type::vm_cnt; }
|
||||
bool is_addr() const { return type == vm_type::vm_addr; }
|
||||
bool is_ret() const { return type == vm_type::vm_ret; }
|
||||
bool is_nil() const { return type == vm_type::vm_nil; }
|
||||
bool is_num() const { return type == vm_type::vm_num; }
|
||||
bool is_str() const { return type == vm_type::vm_str; }
|
||||
bool is_vec() const { return type == vm_type::vm_vec; }
|
||||
bool is_hash() const { return type == vm_type::vm_hash; }
|
||||
bool is_func() const { return type == vm_type::vm_func; }
|
||||
bool is_upval() const { return type == vm_type::vm_upval; }
|
||||
bool is_ghost() const { return type == vm_type::vm_ghost; }
|
||||
bool is_coroutine() const { return type == vm_type::vm_co; }
|
||||
bool is_map() const { return type == vm_type::vm_map; }
|
||||
|
||||
public:
|
||||
// convert to number
|
||||
f64 to_num() const {
|
||||
return type != vm_type::vm_str
|
||||
? val.num
|
||||
: util::str_to_num(str().c_str());
|
||||
}
|
||||
// convert to string
|
||||
std::string to_str();
|
||||
inline bool object_check(const std::string&) const;
|
||||
friend std::ostream& operator<<(std::ostream&, var&);
|
||||
};
|
||||
|
||||
struct nas_vec {
|
||||
std::vector<var> elems;
|
||||
|
||||
// mark if this is printed, avoid stack overflow
|
||||
bool printed = false;
|
||||
|
||||
auto size() const { return elems.size(); }
|
||||
var get_value(const i32 index) {
|
||||
i32 size = elems.size();
|
||||
if (index < -size || index >= size) {
|
||||
return var::none();
|
||||
}
|
||||
return elems[index >= 0 ? index : index + size];
|
||||
}
|
||||
var* get_memory(const i32 index) {
|
||||
i32 size = elems.size();
|
||||
if (index < -size || index >= size) {
|
||||
return nullptr;
|
||||
}
|
||||
return &elems[index >= 0 ? index : index + size];
|
||||
}
|
||||
friend std::ostream& operator<<(std::ostream&, nas_vec&);
|
||||
};
|
||||
|
||||
struct nas_hash {
|
||||
std::unordered_map<std::string, var> elems;
|
||||
|
||||
// mark if this is printed, avoid stack overflow
|
||||
bool printed = false;
|
||||
|
||||
auto size() const { return elems.size(); }
|
||||
var get_value(const std::string&);
|
||||
var* get_memory(const std::string&);
|
||||
friend std::ostream& operator<<(std::ostream&, nas_hash&);
|
||||
};
|
||||
|
||||
struct nas_func {
|
||||
i64 dynamic_parameter_index; // dynamic parameter name index in hash.
|
||||
u64 entry; // pc will set to entry-1 to call this function
|
||||
u32 parameter_size; // used to load default parameters to a new function
|
||||
u64 local_size; // used to expand memory space for local values on stack
|
||||
std::vector<var> local; // local scope with default value(var)
|
||||
std::vector<var> upval; // closure
|
||||
|
||||
// parameter table, u32 begins from 1
|
||||
std::unordered_map<std::string, u32> keys;
|
||||
|
||||
// dynamic parameter name
|
||||
std::string dynamic_parameter_name;
|
||||
|
||||
nas_func():
|
||||
dynamic_parameter_index(-1), entry(0),
|
||||
parameter_size(0), local_size(0),
|
||||
dynamic_parameter_name("") {}
|
||||
void clear();
|
||||
friend std::ostream& operator<<(std::ostream&, nas_func&);
|
||||
};
|
||||
|
||||
struct nas_upval {
|
||||
public:
|
||||
/* on stack, use these variables */
|
||||
bool on_stack;
|
||||
u64 size;
|
||||
var* stack_frame_offset;
|
||||
|
||||
/* not on stack, use this */
|
||||
std::vector<var> elems;
|
||||
|
||||
public:
|
||||
nas_upval(): on_stack(true), size(0), stack_frame_offset(nullptr) {}
|
||||
|
||||
var& operator[](usize n) {
|
||||
return on_stack? stack_frame_offset[n] : elems[n];
|
||||
}
|
||||
|
||||
void clear() {
|
||||
on_stack = true;
|
||||
elems.clear();
|
||||
size = 0;
|
||||
}
|
||||
};
|
||||
|
||||
struct nas_ghost {
|
||||
private:
|
||||
using destructor = void (*)(void*);
|
||||
using marker = void (*)(void*, std::vector<var>*);
|
||||
|
||||
public:
|
||||
std::string type_name;
|
||||
destructor destructor_function;
|
||||
marker gc_mark_function;
|
||||
void* pointer;
|
||||
|
||||
public:
|
||||
nas_ghost():
|
||||
type_name(""), destructor_function(nullptr),
|
||||
gc_mark_function(nullptr), pointer(nullptr) {}
|
||||
~nas_ghost() { clear(); }
|
||||
void set(const std::string&, destructor, marker, void*);
|
||||
void clear();
|
||||
friend std::ostream& operator<<(std::ostream&, const nas_ghost&);
|
||||
|
||||
public:
|
||||
const auto& get_ghost_name() const { return type_name; }
|
||||
|
||||
public:
|
||||
template<typename T>
|
||||
T* get() { return static_cast<T*>(pointer); }
|
||||
template<typename T>
|
||||
T convert() const { return reinterpret_cast<T>(pointer); }
|
||||
};
|
||||
|
||||
struct context {
|
||||
u64 pc = 0;
|
||||
var* localr = nullptr;
|
||||
var* memr = nullptr;
|
||||
var funcr = var::nil();
|
||||
var upvalr = var::nil();
|
||||
var* canary = nullptr;
|
||||
|
||||
var* stack = nullptr;
|
||||
var* top = nullptr;
|
||||
|
||||
var* func_stack = nullptr;
|
||||
var* func_top = nullptr;
|
||||
};
|
||||
|
||||
struct nas_co {
|
||||
enum class status:u32 {
|
||||
suspended,
|
||||
running,
|
||||
dead
|
||||
};
|
||||
|
||||
context ctx;
|
||||
status status;
|
||||
|
||||
nas_co() {
|
||||
ctx.stack = new var[VM_STACK_DEPTH];
|
||||
ctx.func_stack = new var[VM_STACK_DEPTH];
|
||||
clear();
|
||||
}
|
||||
~nas_co() {
|
||||
delete[] ctx.stack;
|
||||
delete[] ctx.func_stack;
|
||||
}
|
||||
void clear();
|
||||
friend std::ostream& operator<<(std::ostream&, const nas_co&);
|
||||
};
|
||||
|
||||
struct nas_map {
|
||||
bool printed = false;
|
||||
std::unordered_map<std::string, var*> mapper;
|
||||
|
||||
public:
|
||||
void clear() {
|
||||
mapper.clear();
|
||||
}
|
||||
auto size() const { return mapper.size(); }
|
||||
|
||||
var get_value(const std::string&);
|
||||
var* get_memory(const std::string&);
|
||||
friend std::ostream& operator<<(std::ostream&, nas_map&);
|
||||
};
|
||||
|
||||
const var zero = var::num(0);
|
||||
const var one = var::num(1);
|
||||
const var nil = var::nil();
|
||||
|
||||
inline bool var::object_check(const std::string& name) const {
|
||||
return is_ghost() && ghost().type_name == name && ghost().pointer;
|
||||
}
|
||||
|
||||
// use to print error log and return error value
|
||||
static var nas_err(const std::string& func, const std::string& info) {
|
||||
std::cerr << "[vm] " << func << ": " << info << "\n";
|
||||
return var::none();
|
||||
}
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "nasal.h"
|
||||
#include "util/util.h"
|
||||
|
||||
#include <cstring>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <unordered_map>
|
||||
|
||||
namespace nasal {
|
||||
|
||||
enum class vm_type: u8 {
|
||||
/* none-gc object */
|
||||
vm_none = 0, // error type
|
||||
vm_cnt, // counter for forindex/foreach loop
|
||||
vm_addr, // var* address
|
||||
vm_ret, // return addres(program counter)
|
||||
vm_nil, // nil
|
||||
vm_num, // number
|
||||
|
||||
/* gc object */
|
||||
vm_str, // string
|
||||
vm_vec, // vector
|
||||
vm_hash, // hashmap(dict)
|
||||
vm_func, // function(lambda)
|
||||
vm_upval, // upvalue
|
||||
vm_ghost, // ghost type
|
||||
vm_co, // coroutine
|
||||
vm_map, // for globals and namespaces
|
||||
|
||||
/* mark type range */
|
||||
vm_type_size_max
|
||||
};
|
||||
|
||||
// size of gc object type
|
||||
const u32 GC_TYPE_SIZE =
|
||||
static_cast<u32>(vm_type::vm_type_size_max) -
|
||||
static_cast<u32>(vm_type::vm_str);
|
||||
|
||||
// basic types
|
||||
struct nas_vec; // vector
|
||||
struct nas_hash; // hashmap(dict)
|
||||
struct nas_func; // function(lambda)
|
||||
struct nas_upval; // upvalue
|
||||
struct nas_ghost; // objects
|
||||
struct nas_co; // coroutine
|
||||
struct nas_map; // mapper
|
||||
|
||||
// nas_val includes gc-managed types
|
||||
struct nas_val {
|
||||
enum class gc_status: u8 {
|
||||
uncollected = 0,
|
||||
collected,
|
||||
found
|
||||
};
|
||||
|
||||
gc_status mark;
|
||||
vm_type type; // value type
|
||||
u8 immutable; // used to mark if a string is immutable
|
||||
union elem {
|
||||
std::string* str;
|
||||
nas_vec* vec;
|
||||
nas_hash* hash;
|
||||
nas_func* func;
|
||||
nas_upval* upval;
|
||||
nas_ghost* obj;
|
||||
nas_co* co;
|
||||
nas_map* map;
|
||||
} ptr;
|
||||
|
||||
nas_val(vm_type);
|
||||
~nas_val();
|
||||
void clear();
|
||||
};
|
||||
|
||||
struct var {
|
||||
public:
|
||||
vm_type type = vm_type::vm_none;
|
||||
union {
|
||||
u64 ret;
|
||||
i64 cnt;
|
||||
f64 num;
|
||||
var* addr;
|
||||
nas_val* gcobj;
|
||||
} val;
|
||||
|
||||
private:
|
||||
var(vm_type t, u64 pc) { type = t; val.ret = pc; }
|
||||
var(vm_type t, i64 ct) { type = t; val.cnt = ct; }
|
||||
var(vm_type t, f64 n) { type = t; val.num = n; }
|
||||
var(vm_type t, var* p) { type = t; val.addr = p; }
|
||||
var(vm_type t, nas_val* p) { type = t; val.gcobj = p; }
|
||||
|
||||
public:
|
||||
var() = default;
|
||||
var(const var&) = default;
|
||||
bool operator==(const var& nr) const {
|
||||
return type == nr.type && val.gcobj == nr.val.gcobj;
|
||||
}
|
||||
bool operator!=(const var& nr) const {
|
||||
return type != nr.type || val.gcobj != nr.val.gcobj;
|
||||
}
|
||||
|
||||
public:
|
||||
// create new var object
|
||||
static var none() {
|
||||
return var(vm_type::vm_none, static_cast<u64>(0));
|
||||
}
|
||||
static var nil() {
|
||||
return var(vm_type::vm_nil, static_cast<u64>(0));
|
||||
}
|
||||
static var ret(u64 pc) {
|
||||
return var(vm_type::vm_ret, pc);
|
||||
}
|
||||
static var cnt(i64 n) {
|
||||
return var(vm_type::vm_cnt, n);
|
||||
}
|
||||
static var num(f64 n) {
|
||||
return var(vm_type::vm_num, n);
|
||||
}
|
||||
static var gcobj(nas_val* p) {
|
||||
return var(p->type, p);
|
||||
}
|
||||
static var addr(var* p) {
|
||||
return var(vm_type::vm_addr, p);
|
||||
}
|
||||
|
||||
public:
|
||||
// get value
|
||||
var* addr() const { return val.addr; }
|
||||
u64 ret() const { return val.ret; }
|
||||
i64& cnt() { return val.cnt; }
|
||||
f64 num() const { return val.num; }
|
||||
|
||||
public:
|
||||
// get gc object
|
||||
std::string& str() { return *val.gcobj->ptr.str; }
|
||||
nas_vec& vec() { return *val.gcobj->ptr.vec; }
|
||||
nas_hash& hash() { return *val.gcobj->ptr.hash; }
|
||||
nas_func& func() { return *val.gcobj->ptr.func; }
|
||||
nas_upval& upval() { return *val.gcobj->ptr.upval; }
|
||||
nas_ghost& ghost() { return *val.gcobj->ptr.obj; }
|
||||
nas_co& co() { return *val.gcobj->ptr.co; }
|
||||
nas_map& map() { return *val.gcobj->ptr.map; }
|
||||
|
||||
|
||||
public:
|
||||
// get const gc object
|
||||
const std::string& str() const { return *val.gcobj->ptr.str; }
|
||||
const nas_vec& vec() const { return *val.gcobj->ptr.vec; }
|
||||
const nas_hash& hash() const { return *val.gcobj->ptr.hash; }
|
||||
const nas_func& func() const { return *val.gcobj->ptr.func; }
|
||||
const nas_upval& upval() const { return *val.gcobj->ptr.upval; }
|
||||
const nas_ghost& ghost() const { return *val.gcobj->ptr.obj; }
|
||||
const nas_co& co() const { return *val.gcobj->ptr.co; }
|
||||
const nas_map& map() const { return *val.gcobj->ptr.map; }
|
||||
|
||||
public:
|
||||
bool is_none() const { return type == vm_type::vm_none; }
|
||||
bool is_cnt() const { return type == vm_type::vm_cnt; }
|
||||
bool is_addr() const { return type == vm_type::vm_addr; }
|
||||
bool is_ret() const { return type == vm_type::vm_ret; }
|
||||
bool is_nil() const { return type == vm_type::vm_nil; }
|
||||
bool is_num() const { return type == vm_type::vm_num; }
|
||||
bool is_str() const { return type == vm_type::vm_str; }
|
||||
bool is_vec() const { return type == vm_type::vm_vec; }
|
||||
bool is_hash() const { return type == vm_type::vm_hash; }
|
||||
bool is_func() const { return type == vm_type::vm_func; }
|
||||
bool is_upval() const { return type == vm_type::vm_upval; }
|
||||
bool is_ghost() const { return type == vm_type::vm_ghost; }
|
||||
bool is_coroutine() const { return type == vm_type::vm_co; }
|
||||
bool is_map() const { return type == vm_type::vm_map; }
|
||||
|
||||
public:
|
||||
// convert to number
|
||||
f64 to_num() const {
|
||||
return type != vm_type::vm_str
|
||||
? val.num
|
||||
: util::str_to_num(str().c_str());
|
||||
}
|
||||
// convert to string
|
||||
std::string to_str();
|
||||
inline bool object_check(const std::string&) const;
|
||||
friend std::ostream& operator<<(std::ostream&, var&);
|
||||
};
|
||||
|
||||
struct nas_vec {
|
||||
std::vector<var> elems;
|
||||
|
||||
// mark if this is printed, avoid stack overflow
|
||||
bool printed = false;
|
||||
|
||||
auto size() const { return elems.size(); }
|
||||
var get_value(const i32 index) {
|
||||
i32 size = elems.size();
|
||||
if (index < -size || index >= size) {
|
||||
return var::none();
|
||||
}
|
||||
return elems[index >= 0 ? index : index + size];
|
||||
}
|
||||
var* get_memory(const i32 index) {
|
||||
i32 size = elems.size();
|
||||
if (index < -size || index >= size) {
|
||||
return nullptr;
|
||||
}
|
||||
return &elems[index >= 0 ? index : index + size];
|
||||
}
|
||||
friend std::ostream& operator<<(std::ostream&, nas_vec&);
|
||||
};
|
||||
|
||||
struct nas_hash {
|
||||
std::unordered_map<std::string, var> elems;
|
||||
|
||||
// mark if this is printed, avoid stack overflow
|
||||
bool printed = false;
|
||||
|
||||
auto size() const { return elems.size(); }
|
||||
var get_value(const std::string&);
|
||||
var* get_memory(const std::string&);
|
||||
friend std::ostream& operator<<(std::ostream&, nas_hash&);
|
||||
};
|
||||
|
||||
struct nas_func {
|
||||
i64 dynamic_parameter_index; // dynamic parameter name index in hash.
|
||||
u64 entry; // pc will set to entry-1 to call this function
|
||||
u32 parameter_size; // used to load default parameters to a new function
|
||||
u64 local_size; // used to expand memory space for local values on stack
|
||||
std::vector<var> local; // local scope with default value(var)
|
||||
std::vector<var> upval; // closure
|
||||
|
||||
// parameter table, u32 begins from 1
|
||||
std::unordered_map<std::string, u32> keys;
|
||||
|
||||
// dynamic parameter name
|
||||
std::string dynamic_parameter_name;
|
||||
|
||||
nas_func():
|
||||
dynamic_parameter_index(-1), entry(0),
|
||||
parameter_size(0), local_size(0),
|
||||
dynamic_parameter_name("") {}
|
||||
void clear();
|
||||
friend std::ostream& operator<<(std::ostream&, nas_func&);
|
||||
};
|
||||
|
||||
struct nas_upval {
|
||||
public:
|
||||
/* on stack, use these variables */
|
||||
bool on_stack;
|
||||
u64 size;
|
||||
var* stack_frame_offset;
|
||||
|
||||
/* not on stack, use this */
|
||||
std::vector<var> elems;
|
||||
|
||||
public:
|
||||
nas_upval(): on_stack(true), size(0), stack_frame_offset(nullptr) {}
|
||||
|
||||
var& operator[](usize n) {
|
||||
return on_stack? stack_frame_offset[n] : elems[n];
|
||||
}
|
||||
|
||||
void clear() {
|
||||
on_stack = true;
|
||||
elems.clear();
|
||||
size = 0;
|
||||
}
|
||||
};
|
||||
|
||||
struct nas_ghost {
|
||||
private:
|
||||
using destructor = void (*)(void*);
|
||||
using marker = void (*)(void*, std::vector<var>*);
|
||||
|
||||
public:
|
||||
std::string type_name;
|
||||
destructor destructor_function;
|
||||
marker gc_mark_function;
|
||||
void* pointer;
|
||||
|
||||
public:
|
||||
nas_ghost():
|
||||
type_name(""), destructor_function(nullptr),
|
||||
gc_mark_function(nullptr), pointer(nullptr) {}
|
||||
~nas_ghost() { clear(); }
|
||||
void set(const std::string&, destructor, marker, void*);
|
||||
void clear();
|
||||
friend std::ostream& operator<<(std::ostream&, const nas_ghost&);
|
||||
|
||||
public:
|
||||
const auto& get_ghost_name() const { return type_name; }
|
||||
|
||||
public:
|
||||
template<typename T>
|
||||
T* get() { return static_cast<T*>(pointer); }
|
||||
template<typename T>
|
||||
T convert() const { return reinterpret_cast<T>(pointer); }
|
||||
};
|
||||
|
||||
struct callsite {
|
||||
var caller;
|
||||
u64 file_index = 0;
|
||||
u64 line = 0;
|
||||
};
|
||||
|
||||
struct context {
|
||||
u64 pc = 0;
|
||||
var* localr = nullptr;
|
||||
var* memr = nullptr;
|
||||
var funcr = var::nil();
|
||||
var upvalr = var::nil();
|
||||
var* canary = nullptr;
|
||||
|
||||
var* stack = nullptr;
|
||||
var* top = nullptr;
|
||||
|
||||
callsite* func_stack = nullptr;
|
||||
callsite* func_top = nullptr;
|
||||
|
||||
const std::string* files = nullptr;
|
||||
|
||||
void ctor() {
|
||||
stack = new var[VM_STACK_DEPTH];
|
||||
func_stack = new callsite[VM_STACK_DEPTH];
|
||||
}
|
||||
void dtor() {
|
||||
delete[] stack;
|
||||
delete[] func_stack;
|
||||
}
|
||||
void clear() {
|
||||
/* set canary and program counter */
|
||||
pc = 0;
|
||||
localr = nullptr;
|
||||
memr = nullptr;
|
||||
funcr = var::nil();
|
||||
upvalr = var::nil();
|
||||
|
||||
/* set canary = stack[VM_STACK_DEPTH-1] */
|
||||
canary = stack + VM_STACK_DEPTH - 1;
|
||||
|
||||
/* nothing is on stack */
|
||||
top = stack;
|
||||
func_top = func_stack - 1;
|
||||
|
||||
/* clear main stack */
|
||||
for (u32 i = 0; i < VM_STACK_DEPTH; ++i) {
|
||||
stack[i] = var::nil();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct nas_co {
|
||||
enum class status:u32 {
|
||||
suspended,
|
||||
running,
|
||||
dead
|
||||
};
|
||||
|
||||
context ctx;
|
||||
status status;
|
||||
|
||||
nas_co() { ctx.ctor(); }
|
||||
~nas_co() { ctx.dtor(); }
|
||||
void clear() { ctx.clear(); status = status::suspended; }
|
||||
friend std::ostream& operator<<(std::ostream&, const nas_co&);
|
||||
};
|
||||
|
||||
struct nas_map {
|
||||
bool printed = false;
|
||||
std::unordered_map<std::string, var*> mapper;
|
||||
|
||||
public:
|
||||
void clear() {
|
||||
mapper.clear();
|
||||
}
|
||||
auto size() const { return mapper.size(); }
|
||||
|
||||
var get_value(const std::string&);
|
||||
var* get_memory(const std::string&);
|
||||
friend std::ostream& operator<<(std::ostream&, nas_map&);
|
||||
};
|
||||
|
||||
const var zero = var::num(0);
|
||||
const var one = var::num(1);
|
||||
const var nil = var::nil();
|
||||
|
||||
inline bool var::object_check(const std::string& name) const {
|
||||
return is_ghost() && ghost().type_name == name && ghost().pointer;
|
||||
}
|
||||
|
||||
// use to print error log and return error value
|
||||
static var nas_err(const std::string& func, const std::string& info) {
|
||||
std::cerr << "[vm] " << func << ": " << info << "\n";
|
||||
return var::none();
|
||||
}
|
||||
|
||||
}
|
||||
1656
src/nasal_vm.cpp
1656
src/nasal_vm.cpp
File diff suppressed because it is too large
Load Diff
@@ -287,13 +287,11 @@ public:
|
||||
|
||||
/* constructor of vm instance */
|
||||
vm() {
|
||||
ctx.stack = new var[VM_STACK_DEPTH];
|
||||
ctx.func_stack = new var[VM_STACK_DEPTH];
|
||||
ctx.ctor();
|
||||
global = new var[VM_STACK_DEPTH];
|
||||
}
|
||||
~vm() {
|
||||
delete[] ctx.stack;
|
||||
delete[] ctx.func_stack;
|
||||
ctx.dtor();
|
||||
delete[] global;
|
||||
}
|
||||
|
||||
@@ -902,7 +900,11 @@ inline void vm::o_callfv() {
|
||||
var tmp = local[-1];
|
||||
local[-1] = ctx.funcr;
|
||||
ctx.funcr = tmp;
|
||||
(++ctx.func_top)[0] = tmp;
|
||||
(++ctx.func_top)[0] = {
|
||||
tmp,
|
||||
bytecode[ctx.pc].fidx,
|
||||
bytecode[ctx.pc].line
|
||||
};
|
||||
|
||||
// top-argc+lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
|
||||
if (ctx.top-argc+func.local_size+3>=ctx.canary) {
|
||||
@@ -972,7 +974,11 @@ inline void vm::o_callfh() {
|
||||
var tmp = ctx.top[-1];
|
||||
ctx.top[-1] = ctx.funcr;
|
||||
ctx.funcr = tmp;
|
||||
(++ctx.func_top)[0] = tmp;
|
||||
(++ctx.func_top)[0] = {
|
||||
tmp,
|
||||
bytecode[ctx.pc].fidx,
|
||||
bytecode[ctx.pc].line
|
||||
};
|
||||
|
||||
// top -1(hash) +lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
|
||||
if (ctx.top+func.local_size+2>= ctx.canary) {
|
||||
@@ -1015,6 +1021,9 @@ inline void vm::o_callb() {
|
||||
// this code is written for coroutine
|
||||
(++ctx.top)[0] = nil;
|
||||
|
||||
// set file list into ctx
|
||||
ctx.files = files;
|
||||
|
||||
// if running a native function about coroutine
|
||||
// (top) will be set to another context.top, instead of main_context.top
|
||||
auto function_pointer = native_function[imm[ctx.pc]].func;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
24
test/caller.nas
Normal file
24
test/caller.nas
Normal file
@@ -0,0 +1,24 @@
|
||||
var a = func(x, y, z) {
|
||||
for (var i = 0; i < 20; i += 1) {
|
||||
var cl = caller(i);
|
||||
if (cl == nil) {
|
||||
return;
|
||||
}
|
||||
print("[", i, "]\t", cl[1], "\t -> called from ", cl[2], ":", cl[3], "\n");
|
||||
}
|
||||
}
|
||||
|
||||
var b = func(x, y) {
|
||||
a(1, 2, 3);
|
||||
}
|
||||
|
||||
var c = func(x) b(1, 2);
|
||||
var d = func c(1);
|
||||
var e = func d();
|
||||
var f = func e();
|
||||
var g = func f();
|
||||
var h = func g();
|
||||
var i = func h();
|
||||
var j = func i();
|
||||
|
||||
j();
|
||||
@@ -109,7 +109,7 @@ for (var t = 0; t < 10; t += 1) {
|
||||
counter += 1;
|
||||
for (var i = 0; i < t + 1; i += 1)
|
||||
coroutine.resume(co);
|
||||
if (counter - int(counter / 1000) * 1000 == 0) {
|
||||
if (counter - int(counter / 2500) * 2500 == 0) {
|
||||
var rate = counter / 2e5;
|
||||
print(" ", bar.bar(rate), " ",
|
||||
padding.leftpad(str(int(rate*100)),3), "% | ",
|
||||
@@ -120,7 +120,7 @@ for (var t = 0; t < 10; t += 1) {
|
||||
}
|
||||
|
||||
tm.stamp();
|
||||
for (var i = 0; i < 1e5; i += 1)
|
||||
for (var i = 0; i < 2e5; i += 1)
|
||||
consumer();
|
||||
println(" ", bar.bar(1), " 100% | ",
|
||||
str(int(1e3 * counter / tm.elapsedMSec())),
|
||||
|
||||
Reference in New Issue
Block a user