🚀 update
This commit is contained in:
ValKmjolnir
parent
af3ade5a41
commit
597c0388cb
|
|
@ -1,160 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#include <iomanip>
|
||||
#include <stack>
|
||||
|
||||
#include "nasal_new_import.h"
|
||||
#include "nasal_new_gc.h"
|
||||
#include "nasal_new_codegen.h"
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning (disable:4244)
|
||||
#pragma warning (disable:4267)
|
||||
#pragma warning (disable:4102)
|
||||
#endif
|
||||
|
||||
class vm {
|
||||
protected:
|
||||
|
||||
/* registers and constants of vm */
|
||||
context ctx;
|
||||
|
||||
/* constants */
|
||||
const f64* cnum=nullptr; // constant numbers
|
||||
const std::string* cstr=nullptr; // constant symbols and strings
|
||||
std::vector<u32> imm; // immediate number table
|
||||
|
||||
/* garbage collector */
|
||||
gc ngc;
|
||||
|
||||
/* main stack */
|
||||
var stack[STACK_DEPTH];
|
||||
|
||||
/* values used for debugger */
|
||||
const std::string* files=nullptr; // file name list
|
||||
const opcode* bytecode=nullptr; // bytecode buffer address
|
||||
|
||||
/* vm initializing function */
|
||||
void init(
|
||||
const std::vector<std::string>&,
|
||||
const std::vector<f64>&,
|
||||
const std::vector<opcode>&,
|
||||
const std::vector<std::string>&,
|
||||
const std::vector<std::string>&);
|
||||
|
||||
/* debug functions */
|
||||
bool verbose;
|
||||
void valinfo(var&);
|
||||
void traceback();
|
||||
void stackinfo(const u32);
|
||||
void reginfo();
|
||||
void gstate();
|
||||
void lstate();
|
||||
void ustate();
|
||||
void detail();
|
||||
void die(const std::string&);
|
||||
|
||||
/* vm calculation functions*/
|
||||
bool cond(var&);
|
||||
|
||||
/* vm operands */
|
||||
void o_intg();
|
||||
void o_intl();
|
||||
void o_loadg();
|
||||
void o_loadl();
|
||||
void o_loadu();
|
||||
void o_pnum();
|
||||
void o_pnil();
|
||||
void o_pstr();
|
||||
void o_newv();
|
||||
void o_newh();
|
||||
void o_newf();
|
||||
void o_happ();
|
||||
void o_para();
|
||||
void o_deft();
|
||||
void o_dyn();
|
||||
void o_lnot();
|
||||
void o_usub();
|
||||
void o_bnot();
|
||||
void o_btor();
|
||||
void o_btxor();
|
||||
void o_btand();
|
||||
void o_add();
|
||||
void o_sub();
|
||||
void o_mul();
|
||||
void o_div();
|
||||
void o_lnk();
|
||||
void o_addc();
|
||||
void o_subc();
|
||||
void o_mulc();
|
||||
void o_divc();
|
||||
void o_lnkc();
|
||||
void o_addeq();
|
||||
void o_subeq();
|
||||
void o_muleq();
|
||||
void o_diveq();
|
||||
void o_lnkeq();
|
||||
void o_bandeq();
|
||||
void o_boreq();
|
||||
void o_bxoreq();
|
||||
void o_addeqc();
|
||||
void o_subeqc();
|
||||
void o_muleqc();
|
||||
void o_diveqc();
|
||||
void o_lnkeqc();
|
||||
void o_addecp();
|
||||
void o_subecp();
|
||||
void o_mulecp();
|
||||
void o_divecp();
|
||||
void o_lnkecp();
|
||||
void o_meq();
|
||||
void o_eq();
|
||||
void o_neq();
|
||||
void o_less();
|
||||
void o_leq();
|
||||
void o_grt();
|
||||
void o_geq();
|
||||
void o_lessc();
|
||||
void o_leqc();
|
||||
void o_grtc();
|
||||
void o_geqc();
|
||||
void o_pop();
|
||||
void o_jmp();
|
||||
void o_jt();
|
||||
void o_jf();
|
||||
void o_cnt();
|
||||
void o_findex();
|
||||
void o_feach();
|
||||
void o_callg();
|
||||
void o_calll();
|
||||
void o_upval();
|
||||
void o_callv();
|
||||
void o_callvi();
|
||||
void o_callh();
|
||||
void o_callfv();
|
||||
void o_callfh();
|
||||
void o_callb();
|
||||
void o_slcbeg();
|
||||
void o_slcend();
|
||||
void o_slc();
|
||||
void o_slc2();
|
||||
void o_mcallg();
|
||||
void o_mcalll();
|
||||
void o_mupval();
|
||||
void o_mcallv();
|
||||
void o_mcallh();
|
||||
void o_ret();
|
||||
|
||||
public:
|
||||
|
||||
/* constructor of vm instance */
|
||||
vm(): ngc(&ctx), verbose(false) {}
|
||||
|
||||
/* execution entry */
|
||||
void run(
|
||||
const codegen&,
|
||||
const linker&,
|
||||
const std::vector<std::string>&,
|
||||
const bool
|
||||
);
|
||||
};
|
||||
98
makefile
98
makefile
|
|
@ -74,79 +74,81 @@ test:nasal
|
|||
@ ./nasal -t -d test/ycombinator.nas
|
||||
|
||||
NASAL_NEW_AST=\
|
||||
nasal_new_misc.o\
|
||||
nasal_new_err.o\
|
||||
nasal_new_gc.o\
|
||||
nasal_new_import.o\
|
||||
nasal_new_lexer.o\
|
||||
nasal_new_ast.o\
|
||||
nasal_new_builtin.o\
|
||||
nasal_new_codegen.o\
|
||||
nasal_new_opcode.o\
|
||||
nasal_new_parse.o\
|
||||
nasal_new_vm.o\
|
||||
nasal_new_dbg.o\
|
||||
optimizer.o\
|
||||
symbol_finder.o\
|
||||
ast_visitor.o\
|
||||
ast_dumper.o\
|
||||
nasal_new_lexer.o\
|
||||
nasal_new_parse.o\
|
||||
nasal_new_import.o\
|
||||
optimizer.o\
|
||||
nasal_new_opcode.o\
|
||||
symbol_finder.o\
|
||||
nasal_new_codegen.o\
|
||||
nasal_new_misc.o\
|
||||
nasal_new_gc.o\
|
||||
nasal_new_builtin.o\
|
||||
nasal_new_vm.o\
|
||||
nasal_new_dbg.o\
|
||||
nasal_new_main.o
|
||||
|
||||
# for test
|
||||
nnew: $(NASAL_NEW_AST)
|
||||
$(CXX) $(NASAL_NEW_AST) -o nnew -ldl
|
||||
@ echo "build done"
|
||||
$(CXX) $(NASAL_NEW_AST) -O3 -o nnew -ldl
|
||||
|
||||
nasal_new_main.o: ast/nasal_new_main.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_main.cpp -fno-exceptions -fPIC -o nasal_new_main.o -I .
|
||||
nnew.exe: $(NASAL_NEW_AST)
|
||||
$(CXX) $(NASAL_NEW_AST) -O3 -o nnew.exe
|
||||
|
||||
nasal_new_misc.o: ast/nasal_new_header.h ast/nasal_new_misc.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_misc.cpp -fno-exceptions -fPIC -o nasal_new_misc.o -I .
|
||||
nasal_new_main.o: src/nasal_new_main.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_main.cpp -fno-exceptions -fPIC -o nasal_new_main.o -I .
|
||||
|
||||
nasal_new_err.o: ast/nasal_new_err.h ast/nasal_new_err.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_err.cpp -fno-exceptions -fPIC -o nasal_new_err.o -I .
|
||||
nasal_new_misc.o: src/nasal_new_header.h src/nasal_new_misc.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_misc.cpp -fno-exceptions -fPIC -o nasal_new_misc.o -I .
|
||||
|
||||
nasal_new_gc.o: ast/nasal_new_gc.h ast/nasal_new_gc.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_gc.cpp -fno-exceptions -fPIC -o nasal_new_gc.o -I .
|
||||
nasal_new_err.o: src/nasal_new_err.h src/nasal_new_err.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_err.cpp -fno-exceptions -fPIC -o nasal_new_err.o -I .
|
||||
|
||||
nasal_new_import.o: ast/nasal_new_import.h ast/nasal_new_import.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_import.cpp -fno-exceptions -fPIC -o nasal_new_import.o -I .
|
||||
nasal_new_gc.o: src/nasal_new_gc.h src/nasal_new_gc.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_gc.cpp -fno-exceptions -fPIC -o nasal_new_gc.o -I .
|
||||
|
||||
nasal_new_lexer.o: ast/nasal_new_lexer.h ast/nasal_new_lexer.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
|
||||
nasal_new_import.o: src/nasal_new_import.h src/nasal_new_import.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_import.cpp -fno-exceptions -fPIC -o nasal_new_import.o -I .
|
||||
|
||||
nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
|
||||
nasal_new_lexer.o: src/nasal_new_lexer.h src/nasal_new_lexer.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
|
||||
|
||||
nasal_new_builtin.o: ast/nasal_new_builtin.h ast/nasal_new_builtin.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.o -I .
|
||||
nasal_new_ast.o: src/nasal_new_ast.h src/nasal_new_ast.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
|
||||
|
||||
nasal_new_codegen.o: ast/nasal_new_codegen.h ast/nasal_new_codegen.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
|
||||
nasal_new_builtin.o: src/nasal_new_builtin.h src/nasal_new_builtin.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.o -I .
|
||||
|
||||
nasal_new_opcode.o: ast/nasal_new_opcode.h ast/nasal_new_opcode.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_opcode.cpp -fno-exceptions -fPIC -o nasal_new_opcode.o -I .
|
||||
nasal_new_codegen.o: src/nasal_new_codegen.h src/nasal_new_codegen.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
|
||||
|
||||
nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp ast/nasal_new_ast.h
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
|
||||
nasal_new_opcode.o: src/nasal_new_opcode.h src/nasal_new_opcode.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_opcode.cpp -fno-exceptions -fPIC -o nasal_new_opcode.o -I .
|
||||
|
||||
optimizer.o: ast/optimizer.h ast/optimizer.cpp ast/nasal_new_ast.h
|
||||
$(CXX) -std=$(STD) -c -O3 ast/optimizer.cpp -fno-exceptions -fPIC -o optimizer.o -I .
|
||||
nasal_new_parse.o: src/nasal_new_parse.h src/nasal_new_parse.cpp src/nasal_new_ast.h
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
|
||||
|
||||
symbol_finder.o: ast/symbol_finder.h ast/symbol_finder.cpp ast/nasal_new_ast.h
|
||||
$(CXX) -std=$(STD) -c -O3 ast/symbol_finder.cpp -fno-exceptions -fPIC -o symbol_finder.o -I .
|
||||
optimizer.o: src/optimizer.h src/optimizer.cpp src/nasal_new_ast.h
|
||||
$(CXX) -std=$(STD) -c -O3 src/optimizer.cpp -fno-exceptions -fPIC -o optimizer.o -I .
|
||||
|
||||
ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
|
||||
symbol_finder.o: src/symbol_finder.h src/symbol_finder.cpp src/nasal_new_ast.h
|
||||
$(CXX) -std=$(STD) -c -O3 src/symbol_finder.cpp -fno-exceptions -fPIC -o symbol_finder.o -I .
|
||||
|
||||
ast_dumper.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_dumper.h ast/ast_dumper.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/ast_dumper.cpp -fno-exceptions -fPIC -o ast_dumper.o -I .
|
||||
ast_visitor.o: src/nasal_new_ast.h src/ast_visitor.h src/ast_visitor.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
|
||||
|
||||
nasal_new_vm.o: ast/nasal_new_vm.h ast/nasal_new_vm.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_vm.cpp -fno-exceptions -fPIC -o nasal_new_vm.o -I .
|
||||
ast_dumper.o: src/nasal_new_ast.h src/ast_visitor.h src/ast_dumper.h src/ast_dumper.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/ast_dumper.cpp -fno-exceptions -fPIC -o ast_dumper.o -I .
|
||||
|
||||
nasal_new_dbg.o: ast/nasal_new_dbg.h ast/nasal_new_dbg.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 ast/nasal_new_dbg.cpp -fno-exceptions -fPIC -o nasal_new_dbg.o -I .
|
||||
nasal_new_vm.o: src/nasal_new_vm.h src/nasal_new_vm.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_vm.cpp -fno-exceptions -fPIC -o nasal_new_vm.o -I .
|
||||
|
||||
nasal_new_dbg.o: src/nasal_new_dbg.h src/nasal_new_dbg.cpp
|
||||
$(CXX) -std=$(STD) -c -O3 src/nasal_new_dbg.cpp -fno-exceptions -fPIC -o nasal_new_dbg.o -I .
|
||||
|
||||
.PHONY: nasal_new_clean
|
||||
nasal_new_clean:
|
||||
|
|
|
|||
|
|
@ -74,6 +74,7 @@ private:
|
|||
void call_sort(const u64*) const;
|
||||
void step_info();
|
||||
void interact();
|
||||
|
||||
public:
|
||||
dbg(error& err):
|
||||
next(false), fsize(0),
|
||||
|
|
@ -1,4 +1,13 @@
|
|||
#include "nasal_new_err.h"
|
||||
#ifdef _WIN32
|
||||
#include <windows.h> // use SetConsoleTextAttribute
|
||||
struct for_reset {
|
||||
CONSOLE_SCREEN_BUFFER_INFO scr;
|
||||
for_reset() {
|
||||
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &scr);
|
||||
}
|
||||
} reset_ter_color;
|
||||
#endif
|
||||
|
||||
std::ostream& back_white(std::ostream& s) {
|
||||
#ifdef _WIN32
|
||||
|
|
@ -16,16 +16,6 @@ struct span {
|
|||
std::string file;
|
||||
};
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h> // use SetConsoleTextAttribute
|
||||
struct for_reset {
|
||||
CONSOLE_SCREEN_BUFFER_INFO scr;
|
||||
for_reset() {
|
||||
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &scr);
|
||||
}
|
||||
} reset_ter_color;
|
||||
#endif
|
||||
|
||||
std::ostream& back_white(std::ostream&);
|
||||
std::ostream& red(std::ostream&);
|
||||
std::ostream& cyan(std::ostream&);
|
||||
|
|
@ -466,57 +466,71 @@ void gc::info() {
|
|||
using std::left;
|
||||
using std::setw;
|
||||
using std::setfill;
|
||||
const char* name[]={"str ","vec ","hash ","func ","upval","obj ","co "};
|
||||
std::clog<<"\ngc info (gc count|alloc count|memory size)\n";
|
||||
const char* name[] = {
|
||||
"string ",
|
||||
"vector ",
|
||||
"hashmap ",
|
||||
"function ",
|
||||
"upvalue ",
|
||||
"object ",
|
||||
"coroutine"
|
||||
};
|
||||
|
||||
usize ident=0;
|
||||
usize indent=0;
|
||||
for(u8 i=0;i<gc_type_size;++i) {
|
||||
#ifndef _MSC_VER
|
||||
usize len=std::max({
|
||||
std::to_string(gcnt[i]).length(),
|
||||
std::to_string(acnt[i]).length(),
|
||||
std::to_string(size[i]).length()
|
||||
});
|
||||
#else // VS is a piece of shit
|
||||
usize len=std::to_string(gcnt[i]).length();
|
||||
ident=ident<len?len:ident;
|
||||
len=std::to_string(acnt[i]).length();
|
||||
ident=ident<len?len:ident;
|
||||
len=std::to_string(size[i]).length();
|
||||
#endif
|
||||
ident=ident<len?len:ident;
|
||||
usize len = 0;
|
||||
len = std::to_string(gcnt[i]).length();
|
||||
indent = indent<len? len:indent;
|
||||
len = std::to_string(acnt[i]).length();
|
||||
indent = indent<len? len:indent;
|
||||
len = std::to_string(size[i]).length();
|
||||
indent = indent<len? len:indent;
|
||||
}
|
||||
|
||||
double total=0;
|
||||
for(u8 i=0;i<gc_type_size;++i) {
|
||||
if (gcnt[i] || acnt[i] || size[i]) {
|
||||
total+=gcnt[i];
|
||||
std::clog<<" "<<name[i];
|
||||
std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<gcnt[i];
|
||||
std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<acnt[i];
|
||||
std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<size[i];
|
||||
std::clog<<"\n";
|
||||
std::clog << "\ngc info (gc count|alloc count|memory size)\n";
|
||||
for(u8 i = 0; i<gc_type_size; ++i) {
|
||||
if (!gcnt[i] && !acnt[i] && !size[i]) {
|
||||
continue;
|
||||
}
|
||||
total += gcnt[i];
|
||||
std::clog << " " << name[i];
|
||||
std::clog << " | " << left << setw(indent) << setfill(' ') << gcnt[i];
|
||||
std::clog << " | " << left << setw(indent) << setfill(' ') << acnt[i];
|
||||
std::clog << " | " << left << setw(indent) << setfill(' ') << size[i];
|
||||
std::clog << "\n";
|
||||
}
|
||||
|
||||
double sec=worktime*1.0/1000000000; // seconds
|
||||
std::clog<<" time | "<<(sec<0.1? sec*1000:sec)<<(sec<0.1? " ms\n":" s\n");
|
||||
auto den = std::chrono::high_resolution_clock::duration::period::den;
|
||||
std::clog << " gc time | " << worktime*1.0/den*1000 << " ms\n";
|
||||
if (total) {
|
||||
std::clog<<" avg | "<<sec/total*1000<<" ms\n";
|
||||
std::clog << " avg time | " << worktime*1.0/den*1000/total << " ms\n";
|
||||
std::clog << " max gc | " << max_time*1.0/den*1000 << " ms\n";
|
||||
std::clog << " max mark | " << max_mark_time*1.0/den*1000 << " ms\n";
|
||||
std::clog << " max sweep | " << max_sweep_time*1.0/den*1000 << " ms\n";
|
||||
}
|
||||
std::clog<<"\n";
|
||||
}
|
||||
|
||||
var gc::alloc(u8 type) {
|
||||
using clk=std::chrono::high_resolution_clock;
|
||||
const u8 index=type-vm_str;
|
||||
using clk = std::chrono::high_resolution_clock;
|
||||
const u8 index = type-vm_str;
|
||||
++acnt[index];
|
||||
if (unused[index].empty()) {
|
||||
++gcnt[index];
|
||||
auto begin=clk::now();
|
||||
auto begin = clk::now();
|
||||
mark();
|
||||
auto mark_end = clk::now();
|
||||
sweep();
|
||||
worktime+=(clk::now()-begin).count();
|
||||
auto sweep_end = clk::now();
|
||||
|
||||
auto total_time = (sweep_end-begin).count();
|
||||
auto mark_time = (mark_end-begin).count();
|
||||
auto sweep_time = (sweep_end-mark_end).count();
|
||||
worktime += total_time;
|
||||
max_time = max_time<total_time? total_time:max_time;
|
||||
max_mark_time = max_mark_time<mark_time? mark_time:max_mark_time;
|
||||
max_sweep_time = max_sweep_time<sweep_time? sweep_time:max_sweep_time;
|
||||
}
|
||||
if (unused[index].empty()) {
|
||||
extend(type);
|
||||
|
|
@ -327,8 +327,8 @@ struct gc {
|
|||
context mctx;
|
||||
|
||||
/* runtime context */
|
||||
context* rctx;
|
||||
nas_co* cort=nullptr; // running coroutine
|
||||
context* rctx = nullptr;
|
||||
nas_co* cort = nullptr; // running coroutine
|
||||
|
||||
/* temporary space used in builtin/module functions */
|
||||
var temp=nil;
|
||||
|
|
@ -340,7 +340,7 @@ struct gc {
|
|||
std::vector<nas_val*> unused[gc_type_size]; // gc free list
|
||||
|
||||
/* heap increase size */
|
||||
u32 incr[gc_type_size]={
|
||||
u32 incr[gc_type_size] = {
|
||||
128, // vm_str
|
||||
128, // vm_vec
|
||||
64, // vm_hash
|
||||
|
|
@ -354,7 +354,10 @@ struct gc {
|
|||
u64 size[gc_type_size];
|
||||
u64 gcnt[gc_type_size];
|
||||
u64 acnt[gc_type_size];
|
||||
i64 worktime=0;
|
||||
i64 worktime = 0;
|
||||
i64 max_time = 0;
|
||||
i64 max_mark_time = 0;
|
||||
i64 max_sweep_time = 0;
|
||||
|
||||
gc(context* _ctx): rctx(_ctx) {}
|
||||
|
||||
|
|
@ -15,12 +15,13 @@
|
|||
#include <unordered_map>
|
||||
#include <thread>
|
||||
|
||||
const u32 VM_AST =0x01;
|
||||
const u32 VM_CODE =0x02;
|
||||
const u32 VM_TIME =0x04;
|
||||
const u32 VM_EXEC =0x08;
|
||||
const u32 VM_DETAIL=0x10;
|
||||
const u32 VM_DEBUG =0x20;
|
||||
const u32 VM_RAW_AST = 1;
|
||||
const u32 VM_AST = 1<<1;
|
||||
const u32 VM_CODE = 1<<2;
|
||||
const u32 VM_TIME = 1<<3;
|
||||
const u32 VM_EXEC = 1<<4;
|
||||
const u32 VM_DETAIL = 1<<5;
|
||||
const u32 VM_DEBUG = 1<<6;
|
||||
|
||||
std::ostream& help(std::ostream& out) {
|
||||
out
|
||||
|
|
@ -32,19 +33,20 @@ std::ostream& help(std::ostream& out) {
|
|||
#endif
|
||||
<<"\nnasal <option>\n"
|
||||
<<"option:\n"
|
||||
<<" -h, --help | get help.\n"
|
||||
<<" -h, --help | get help.\n"
|
||||
<<"\nnasal [option] <file> [argv]\n"
|
||||
<<"option:\n"
|
||||
<<" -a, --ast | view abstract syntax tree.\n"
|
||||
<<" -c, --code | view bytecode.\n"
|
||||
<<" -e, --exec | execute.\n"
|
||||
<<" -t, --time | show execute time.\n"
|
||||
<<" -d, --detail | get detail info.\n"
|
||||
<<" -dbg, --debug | debug mode.\n"
|
||||
<<" -a, --ast | view ast (after link/optimize process).\n"
|
||||
<<" --raw-ast | view ast without after-processing.\n"
|
||||
<<" -c, --code | view bytecode.\n"
|
||||
<<" -e, --exec | execute.\n"
|
||||
<<" -t, --time | show execute time.\n"
|
||||
<<" -d, --detail | get detail info.\n"
|
||||
<<" -dbg, --debug | debug mode.\n"
|
||||
<<"file:\n"
|
||||
<<" <filename> | execute file.\n"
|
||||
<<" <filename> | execute file.\n"
|
||||
<<"argv:\n"
|
||||
<<" <args> | cmd arguments used in program.\n";
|
||||
<<" <args> | cmd arguments used in program.\n";
|
||||
return out;
|
||||
}
|
||||
|
||||
|
|
@ -93,18 +95,24 @@ void execute(
|
|||
|
||||
// parser gets lexer's token list to compile
|
||||
parse.compile(lex).chkerr();
|
||||
if (cmd&VM_RAW_AST) {
|
||||
auto dumper = new ast_dumper;
|
||||
dumper->dump(parse.tree());
|
||||
delete dumper;
|
||||
}
|
||||
|
||||
// linker gets parser's ast and load import files to this ast
|
||||
ld.link(parse, file, cmd&VM_DETAIL).chkerr();
|
||||
if (cmd&VM_AST) {
|
||||
auto dumper = new ast_dumper();
|
||||
dumper->dump(parse.tree());
|
||||
}
|
||||
|
||||
|
||||
// optimizer does simple optimization on ast
|
||||
auto opt = new optimizer;
|
||||
opt->do_optimization(parse.tree());
|
||||
delete opt;
|
||||
if (cmd&VM_AST) {
|
||||
auto dumper = new ast_dumper;
|
||||
dumper->dump(parse.tree());
|
||||
delete dumper;
|
||||
}
|
||||
|
||||
// code generator gets parser's ast and import file list to generate code
|
||||
gen.compile(parse, ld).chkerr();
|
||||
|
|
@ -149,6 +157,7 @@ i32 main(i32 argc, const char* argv[]) {
|
|||
|
||||
// execute with arguments
|
||||
const std::unordered_map<std::string,u32> cmdlst = {
|
||||
{"--raw-ast", VM_RAW_AST},
|
||||
{"--ast", VM_AST},
|
||||
{"-a", VM_AST},
|
||||
{"--code", VM_CODE},
|
||||
|
|
@ -0,0 +1,412 @@
|
|||
#include "nasal_new_vm.h"
|
||||
|
||||
void vm::init(
|
||||
const std::vector<std::string>& strs,
|
||||
const std::vector<f64>& nums,
|
||||
const std::vector<opcode>& code,
|
||||
const std::vector<std::string>& filenames,
|
||||
const std::vector<std::string>& argv
|
||||
) {
|
||||
cnum=nums.data();
|
||||
cstr=strs.data();
|
||||
bytecode=code.data();
|
||||
files=filenames.data();
|
||||
|
||||
/* set canary and program counter */
|
||||
ctx.pc=0;
|
||||
ctx.localr=ctx.memr=nullptr;
|
||||
ctx.funcr=ctx.upvalr=nil;
|
||||
ctx.canary=stack+STACK_DEPTH-1; // stack[STACK_DEPTH-1]
|
||||
ctx.top=stack;
|
||||
ctx.stack=stack;
|
||||
|
||||
/* clear main stack */
|
||||
for(u32 i=0;i<STACK_DEPTH;++i) {
|
||||
stack[i]=nil;
|
||||
}
|
||||
|
||||
/* init gc */
|
||||
ngc.init(strs,argv);
|
||||
}
|
||||
|
||||
void vm::valinfo(var& val) {
|
||||
const nas_val* p=val.val.gcobj;
|
||||
switch(val.type) {
|
||||
case vm_none: std::clog<<"| null |";break;
|
||||
case vm_ret: std::clog<<"| pc | 0x"<<std::hex
|
||||
<<val.ret()<<std::dec;break;
|
||||
case vm_addr: std::clog<<"| addr | 0x"<<std::hex
|
||||
<<(u64)val.addr()<<std::dec;break;
|
||||
case vm_cnt: std::clog<<"| cnt | "<<val.cnt();break;
|
||||
case vm_nil: std::clog<<"| nil |";break;
|
||||
case vm_num: std::clog<<"| num | "<<val.num();break;
|
||||
case vm_str: std::clog<<"| str | <0x"<<std::hex<<(u64)p
|
||||
<<"> "<<rawstr(val.str(),16)<<std::dec;break;
|
||||
case vm_func: std::clog<<"| func | <0x"<<std::hex<<(u64)p
|
||||
<<"> entry:0x"<<val.func().entry
|
||||
<<std::dec;break;
|
||||
case vm_upval:std::clog<<"| upval| <0x"<<std::hex<<(u64)p
|
||||
<<std::dec<<"> ["<<val.upval().size
|
||||
<<" val]";break;
|
||||
case vm_vec: std::clog<<"| vec | <0x"<<std::hex<<(u64)p
|
||||
<<std::dec<<"> ["<<val.vec().size()
|
||||
<<" val]";break;
|
||||
case vm_hash: std::clog<<"| hash | <0x"<<std::hex<<(u64)p
|
||||
<<std::dec<<"> {"<<val.hash().size()
|
||||
<<" val}";break;
|
||||
case vm_obj: std::clog<<"| obj | <0x"<<std::hex<<(u64)p
|
||||
<<"> obj:0x"<<(u64)val.obj().ptr
|
||||
<<std::dec;break;
|
||||
case vm_co: std::clog<<"| co | <0x"<<std::hex<<(u64)p
|
||||
<<std::dec<<"> coroutine";break;
|
||||
default: std::clog<<"| err | <0x"<<std::hex<<(u64)p
|
||||
<<std::dec<<"> unknown object";break;
|
||||
}
|
||||
std::clog<<"\n";
|
||||
}
|
||||
|
||||
void vm::traceback() {
|
||||
/* bytecode[0].num is the global size */
|
||||
var* bottom=ngc.rctx->stack==stack?stack+bytecode[0].num:ngc.rctx->stack;
|
||||
var* ctx_top=ngc.rctx->stack==stack?ctx.top:ngc.rctx->top;
|
||||
std::stack<u32> ret;
|
||||
for(var* i=bottom;i<=ctx_top;++i) {
|
||||
if (i->type==vm_ret && i->ret()!=0) {
|
||||
ret.push(i->ret());
|
||||
}
|
||||
}
|
||||
ret.push(ctx.pc); // store the position program crashed
|
||||
std::clog<<"trace back ("<<(ngc.rctx->stack==stack?"main":"coroutine")<<")\n";
|
||||
codestream::set(cnum, cstr, files);
|
||||
for(u32 p=0,same=0,prev=0xffffffff;!ret.empty();prev=p,ret.pop()) {
|
||||
if ((p=ret.top())==prev) {
|
||||
++same;
|
||||
continue;
|
||||
}
|
||||
if (same) {
|
||||
std::clog
|
||||
<<" 0x"<<std::hex<<std::setw(6)<<std::setfill('0')
|
||||
<<prev<<std::dec<<" "<<same<<" same call(s)\n";
|
||||
}
|
||||
same=0;
|
||||
std::clog<<" "<<codestream(bytecode[p],p)<<"\n";
|
||||
}
|
||||
// the first called place has no same calls
|
||||
}
|
||||
|
||||
void vm::stackinfo(const u32 limit=10) {
|
||||
/* bytecode[0].num is the global size */
|
||||
const u32 gsize=ngc.rctx->stack==stack?bytecode[0].num:0;
|
||||
var* t=ctx.top;
|
||||
var* bottom=ngc.rctx->stack+gsize;
|
||||
std::clog<<"stack (0x"<<std::hex<<(u64)bottom<<std::dec
|
||||
<<" <+"<<gsize<<">, limit "<<limit<<", total "
|
||||
<<(t<bottom? 0:(i64)(t-bottom+1))<<")\n";
|
||||
for(u32 i=0;i<limit && t>=bottom;++i,--t) {
|
||||
std::clog<<" 0x"<<std::hex
|
||||
<<std::setw(6)<<std::setfill('0')
|
||||
<<(u64)(t-ngc.rctx->stack)<<std::dec
|
||||
<<" ";
|
||||
valinfo(t[0]);
|
||||
}
|
||||
}
|
||||
|
||||
void vm::reginfo() {
|
||||
std::clog<<"registers ("<<(ngc.cort?"coroutine":"main")<<")\n"<<std::hex
|
||||
<<" [pc ] | pc | 0x"<<ctx.pc<<"\n"
|
||||
<<" [global] | addr | 0x"<<(u64)stack<<"\n"
|
||||
<<" [local ] | addr | 0x"<<(u64)ctx.localr<<"\n"
|
||||
<<" [memr ] | addr | 0x"<<(u64)ctx.memr<<"\n"
|
||||
<<" [canary] | addr | 0x"<<(u64)ctx.canary<<"\n"
|
||||
<<" [top ] | addr | 0x"<<(u64)ctx.top<<"\n"
|
||||
<<std::dec;
|
||||
std::clog<<" [funcr ] ";valinfo(ctx.funcr);
|
||||
std::clog<<" [upval ] ";valinfo(ctx.upvalr);
|
||||
}
|
||||
|
||||
void vm::gstate() {
|
||||
if (!bytecode[0].num || stack[0].type==vm_none) { // bytecode[0].op is op_intg
|
||||
return;
|
||||
}
|
||||
std::clog<<"global (0x"<<std::hex<<(u64)stack<<" <+0>)\n"<<std::dec;
|
||||
for(u32 i=0;i<bytecode[0].num;++i) {
|
||||
std::clog<<" 0x"<<std::hex<<std::setw(6)
|
||||
<<std::setfill('0')<<i<<std::dec
|
||||
<<" ";
|
||||
valinfo(stack[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void vm::lstate() {
|
||||
if (!ctx.localr || !ctx.funcr.func().lsize) {
|
||||
return;
|
||||
}
|
||||
const u32 lsize=ctx.funcr.func().lsize;
|
||||
std::clog<<"local (0x"<<std::hex<<(u64)ctx.localr
|
||||
<<" <+"<<(u64)(ctx.localr-ngc.rctx->stack)<<">)\n"<<std::dec;
|
||||
for(u32 i=0;i<lsize;++i) {
|
||||
std::clog<<" 0x"<<std::hex<<std::setw(6)
|
||||
<<std::setfill('0')<<i<<std::dec
|
||||
<<" ";
|
||||
valinfo(ctx.localr[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void vm::ustate() {
|
||||
if (ctx.funcr.type==vm_nil || ctx.funcr.func().upval.empty()) {
|
||||
return;
|
||||
}
|
||||
std::clog<<"upvalue\n";
|
||||
auto& upval=ctx.funcr.func().upval;
|
||||
for(u32 i=0;i<upval.size();++i) {
|
||||
std::clog<<" -> upval["<<i<<"]:\n";
|
||||
auto& uv=upval[i].upval();
|
||||
for(u32 j=0;j<uv.size;++j) {
|
||||
std::clog<<" 0x"<<std::hex<<std::setw(6)
|
||||
<<std::setfill('0')<<j<<std::dec
|
||||
<<" ";
|
||||
valinfo(uv[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void vm::detail() {
|
||||
reginfo();
|
||||
gstate();
|
||||
lstate();
|
||||
ustate();
|
||||
}
|
||||
|
||||
void vm::die(const std::string& str) {
|
||||
std::cerr<<"[vm] error: "<<str<<"\n";
|
||||
traceback();
|
||||
stackinfo();
|
||||
|
||||
// show verbose crash info
|
||||
if (verbose) {
|
||||
detail();
|
||||
}
|
||||
|
||||
if (ngc.rctx->stack==stack) { // in main context, exit directly
|
||||
std::exit(1);
|
||||
} else {
|
||||
// in coroutine, shut down the coroutine and return to main context
|
||||
ctx.pc=0; // mark coroutine 'dead'
|
||||
ngc.ctxreserve();
|
||||
ctx.top[0]=nil;
|
||||
}
|
||||
}
|
||||
|
||||
void vm::run(
|
||||
const codegen& gen,
|
||||
const linker& linker,
|
||||
const std::vector<std::string>& argv,
|
||||
const bool detail
|
||||
) {
|
||||
verbose=detail;
|
||||
init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
|
||||
#ifndef _MSC_VER
|
||||
const void* oprs[]={
|
||||
&&vmexit, &&intg, &&intl, &&loadg,
|
||||
&&loadl, &&loadu, &&pnum, &&pnil,
|
||||
&&pstr, &&newv, &&newh, &&newf,
|
||||
&&happ, &¶, &&deft, &&dyn,
|
||||
&&lnot, &&usub, &&bnot, &&btor,
|
||||
&&btxor, &&btand, &&add, &&sub,
|
||||
&&mul, &&div, &&lnk, &&addc,
|
||||
&&subc, &&mulc, &&divc, &&lnkc,
|
||||
&&addeq, &&subeq, &&muleq, &&diveq,
|
||||
&&lnkeq, &&bandeq, &&boreq, &&bxoreq,
|
||||
&&addeqc, &&subeqc, &&muleqc, &&diveqc,
|
||||
&&lnkeqc, &&addecp, &&subecp, &&mulecp,
|
||||
&&divecp, &&lnkecp, &&meq, &&eq,
|
||||
&&neq, &&less, &&leq, &&grt,
|
||||
&&geq, &&lessc, &&leqc, &&grtc,
|
||||
&&geqc, &&pop, &&jmp, &&jt,
|
||||
&&jf, &&cnt, &&findex, &&feach,
|
||||
&&callg, &&calll, &&upval, &&callv,
|
||||
&&callvi, &&callh, &&callfv, &&callfh,
|
||||
&&callb, &&slcbeg, &&slcend, &&slc,
|
||||
&&slc2, &&mcallg, &&mcalll, &&mupval,
|
||||
&&mcallv, &&mcallh, &&ret
|
||||
};
|
||||
std::vector<const void*> code;
|
||||
for(auto& i:gen.codes()) {
|
||||
code.push_back(oprs[i.op]);
|
||||
imm.push_back(i.num);
|
||||
}
|
||||
// goto the first operand
|
||||
goto *code[ctx.pc];
|
||||
#else
|
||||
typedef void (vm::*nafunc)();
|
||||
const nafunc oprs[]={
|
||||
nullptr, &vm::o_intg,
|
||||
&vm::o_intl, &vm::o_loadg,
|
||||
&vm::o_loadl, &vm::o_loadu,
|
||||
&vm::o_pnum, &vm::o_pnil,
|
||||
&vm::o_pstr, &vm::o_newv,
|
||||
&vm::o_newh, &vm::o_newf,
|
||||
&vm::o_happ, &vm::o_para,
|
||||
&vm::o_deft, &vm::o_dyn,
|
||||
&vm::o_lnot, &vm::o_usub,
|
||||
&vm::o_bnot, &vm::o_btor,
|
||||
&vm::o_btxor, &vm::o_btand,
|
||||
&vm::o_add, &vm::o_sub,
|
||||
&vm::o_mul, &vm::o_div,
|
||||
&vm::o_lnk, &vm::o_addc,
|
||||
&vm::o_subc, &vm::o_mulc,
|
||||
&vm::o_divc, &vm::o_lnkc,
|
||||
&vm::o_addeq, &vm::o_subeq,
|
||||
&vm::o_muleq, &vm::o_diveq,
|
||||
&vm::o_lnkeq, &vm::o_bandeq,
|
||||
&vm::o_boreq, &vm::o_bxoreq,
|
||||
&vm::o_addeqc, &vm::o_subeqc,
|
||||
&vm::o_muleqc, &vm::o_diveqc,
|
||||
&vm::o_lnkeqc, &vm::o_addecp,
|
||||
&vm::o_subecp, &vm::o_mulecp,
|
||||
&vm::o_divecp, &vm::o_lnkecp,
|
||||
&vm::o_meq, &vm::o_eq,
|
||||
&vm::o_neq, &vm::o_less,
|
||||
&vm::o_leq, &vm::o_grt,
|
||||
&vm::o_geq, &vm::o_lessc,
|
||||
&vm::o_leqc, &vm::o_grtc,
|
||||
&vm::o_geqc, &vm::o_pop,
|
||||
&vm::o_jmp, &vm::o_jt,
|
||||
&vm::o_jf, &vm::o_cnt,
|
||||
&vm::o_findex, &vm::o_feach,
|
||||
&vm::o_callg, &vm::o_calll,
|
||||
&vm::o_upval, &vm::o_callv,
|
||||
&vm::o_callvi, &vm::o_callh,
|
||||
&vm::o_callfv, &vm::o_callfh,
|
||||
&vm::o_callb, &vm::o_slcbeg,
|
||||
&vm::o_slcend, &vm::o_slc,
|
||||
&vm::o_slc2, &vm::o_mcallg,
|
||||
&vm::o_mcalll, &vm::o_mupval,
|
||||
&vm::o_mcallv, &vm::o_mcallh,
|
||||
&vm::o_ret
|
||||
};
|
||||
std::vector<nafunc> code;
|
||||
for(auto& i:gen.codes()) {
|
||||
code.push_back(oprs[i.op]);
|
||||
imm.push_back(i.num);
|
||||
}
|
||||
while(code[ctx.pc]) {
|
||||
(this->*code[ctx.pc])();
|
||||
if (ctx.top>=ctx.canary) {
|
||||
die("stack overflow");
|
||||
}
|
||||
++ctx.pc;
|
||||
}
|
||||
#endif
|
||||
|
||||
vmexit:
|
||||
if (detail) {
|
||||
ngc.info();
|
||||
}
|
||||
ngc.clear();
|
||||
imm.clear();
|
||||
return;
|
||||
|
||||
#ifndef _MSC_VER
|
||||
// may cause stackoverflow
|
||||
#define exec_check(op) {\
|
||||
op();\
|
||||
if (ctx.top<ctx.canary)\
|
||||
goto *code[++ctx.pc];\
|
||||
die("stack overflow");\
|
||||
goto *code[++ctx.pc];\
|
||||
}
|
||||
// do not cause stackoverflow
|
||||
#define exec_nodie(op) {\
|
||||
op();\
|
||||
goto *code[++ctx.pc];\
|
||||
}
|
||||
|
||||
intg: exec_nodie(o_intg ); // +imm[pc] (detected at codegen)
|
||||
intl: exec_nodie(o_intl ); // -0
|
||||
loadg: exec_nodie(o_loadg ); // -1
|
||||
loadl: exec_nodie(o_loadl ); // -1
|
||||
loadu: exec_nodie(o_loadu ); // -1
|
||||
pnum: exec_check(o_pnum ); // +1
|
||||
pnil: exec_check(o_pnil ); // +1
|
||||
pstr: exec_check(o_pstr ); // +1
|
||||
newv: exec_check(o_newv ); // +1-imm[pc]
|
||||
newh: exec_check(o_newh ); // +1
|
||||
newf: exec_check(o_newf ); // +1
|
||||
happ: exec_nodie(o_happ ); // -1
|
||||
para: exec_nodie(o_para ); // -0
|
||||
deft: exec_nodie(o_deft ); // -1
|
||||
dyn: exec_nodie(o_dyn ); // -0
|
||||
lnot: exec_nodie(o_lnot ); // -0
|
||||
usub: exec_nodie(o_usub ); // -0
|
||||
bnot: exec_nodie(o_bnot ); // -0
|
||||
btor: exec_nodie(o_btor ); // -1
|
||||
btxor: exec_nodie(o_btxor ); // -1
|
||||
btand: exec_nodie(o_btand ); // -1
|
||||
add: exec_nodie(o_add ); // -1
|
||||
sub: exec_nodie(o_sub ); // -1
|
||||
mul: exec_nodie(o_mul ); // -1
|
||||
div: exec_nodie(o_div ); // -1
|
||||
lnk: exec_nodie(o_lnk ); // -1
|
||||
addc: exec_nodie(o_addc ); // -0
|
||||
subc: exec_nodie(o_subc ); // -0
|
||||
mulc: exec_nodie(o_mulc ); // -0
|
||||
divc: exec_nodie(o_divc ); // -0
|
||||
lnkc: exec_nodie(o_lnkc ); // -0
|
||||
addeq: exec_nodie(o_addeq ); // -1
|
||||
subeq: exec_nodie(o_subeq ); // -1
|
||||
muleq: exec_nodie(o_muleq ); // -1
|
||||
diveq: exec_nodie(o_diveq ); // -1
|
||||
lnkeq: exec_nodie(o_lnkeq ); // -1
|
||||
bandeq: exec_nodie(o_bandeq); // -1
|
||||
boreq: exec_nodie(o_boreq ); // -1
|
||||
bxoreq: exec_nodie(o_bxoreq); // -1
|
||||
addeqc: exec_nodie(o_addeqc); // -0
|
||||
subeqc: exec_nodie(o_subeqc); // -0
|
||||
muleqc: exec_nodie(o_muleqc); // -0
|
||||
diveqc: exec_nodie(o_diveqc); // -0
|
||||
lnkeqc: exec_nodie(o_lnkeqc); // -0
|
||||
addecp: exec_nodie(o_addecp); // -1
|
||||
subecp: exec_nodie(o_subecp); // -1
|
||||
mulecp: exec_nodie(o_mulecp); // -1
|
||||
divecp: exec_nodie(o_divecp); // -1
|
||||
lnkecp: exec_nodie(o_lnkecp); // -1
|
||||
meq: exec_nodie(o_meq ); // -1
|
||||
eq: exec_nodie(o_eq ); // -1
|
||||
neq: exec_nodie(o_neq ); // -1
|
||||
less: exec_nodie(o_less ); // -1
|
||||
leq: exec_nodie(o_leq ); // -1
|
||||
grt: exec_nodie(o_grt ); // -1
|
||||
geq: exec_nodie(o_geq ); // -1
|
||||
lessc: exec_nodie(o_lessc ); // -0
|
||||
leqc: exec_nodie(o_leqc ); // -0
|
||||
grtc: exec_nodie(o_grtc ); // -0
|
||||
geqc: exec_nodie(o_geqc ); // -0
|
||||
pop: exec_nodie(o_pop ); // -1
|
||||
jmp: exec_nodie(o_jmp ); // -0
|
||||
jt: exec_nodie(o_jt ); // -0
|
||||
jf: exec_nodie(o_jf ); // -1
|
||||
cnt: exec_nodie(o_cnt ); // -0
|
||||
findex: exec_check(o_findex); // +1
|
||||
feach: exec_check(o_feach ); // +1
|
||||
callg: exec_check(o_callg ); // +1
|
||||
calll: exec_check(o_calll ); // +1
|
||||
upval: exec_check(o_upval ); // +1
|
||||
callv: exec_nodie(o_callv ); // -0
|
||||
callvi: exec_nodie(o_callvi); // -0
|
||||
callh: exec_nodie(o_callh ); // -0
|
||||
callfv: exec_nodie(o_callfv); // check in the function
|
||||
callfh: exec_nodie(o_callfh); // check in the function
|
||||
callb: exec_nodie(o_callb ); // -0
|
||||
slcbeg: exec_check(o_slcbeg); // +1
|
||||
slcend: exec_nodie(o_slcend); // -1
|
||||
slc: exec_nodie(o_slc ); // -1
|
||||
slc2: exec_nodie(o_slc2 ); // -2
|
||||
mcallg: exec_check(o_mcallg); // +1
|
||||
mcalll: exec_check(o_mcalll); // +1
|
||||
mupval: exec_check(o_mupval); // +1
|
||||
mcallv: exec_nodie(o_mcallv); // -0
|
||||
mcallh: exec_nodie(o_mcallh); // -0
|
||||
ret: exec_nodie(o_ret ); // -2
|
||||
#endif
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -20,6 +20,7 @@ bool symbol_finder::visit_iter_expr(iter_expr* node) {
|
|||
if (node->get_name()) {
|
||||
symbols.push_back(node->get_name()->get_name());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
const std::vector<std::string>& symbol_finder::do_find(code_block* root) {
|
||||
Loading…
Reference in New Issue