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

🐛 fix header in module for vs to build

This commit is contained in:
ValKmjolnir 2023-05-11 19:41:39 +08:00
parent d954a3fc5e
commit dfb0c6ab52
4 changed files with 709 additions and 702 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

196
module/fib.cpp
View File

@ -1,99 +1,99 @@
// module for test // module for test
#include <iostream> #include <iostream>
#include "../nasal.h" #include "../nasal.h"
namespace nasal_fib_module { namespace nasal_fib_module {
double fibonaci(double x) { double fibonaci(double x) {
if (x<=2) { if (x<=2) {
return x; return x;
} }
return fibonaci(x-1)+fibonaci(x-2); return fibonaci(x-1)+fibonaci(x-2);
} }
var fib(var* args, usize size, gc* ngc) { var fib(var* args, usize size, gc* ngc) {
if (!size) { if (!size) {
return nas_err("fib","lack arguments"); return nas_err("fib","lack arguments");
} }
var num=args[0]; var num=args[0];
return var::num(fibonaci(num.tonum())); return var::num(fibonaci(num.tonum()));
} }
var quick_fib(var* args, usize size, gc* ngc) { var quick_fib(var* args, usize size, gc* ngc) {
if (!size) { if (!size) {
return nas_err("quick_fib","lack arguments"); return nas_err("quick_fib","lack arguments");
} }
double num=args[0].tonum(); double num=args[0].tonum();
if (num<2) { if (num<2) {
return var::num(num); return var::num(num);
} }
double a=1,b=1,res=0; double a=1,b=1,res=0;
for(double i=1;i<num;i+=1) { for(double i=1;i<num;i+=1) {
res=a+b; res=a+b;
a=b; a=b;
b=res; b=res;
} }
return var::num(res); return var::num(res);
} }
u32 ghost_for_test; u32 ghost_for_test;
void ghost_for_test_destructor(void* ptr) { void ghost_for_test_destructor(void* ptr) {
std::cout<<"ghost_for_test::destructor (0x"; std::cout<<"ghost_for_test::destructor (0x";
std::cout<<std::hex<<(u64)ptr<<std::dec<<") {\n"; std::cout<<std::hex<<(u64)ptr<<std::dec<<") {\n";
delete (u32*)ptr; delete (u32*)ptr;
std::cout<<" delete 0x"<<std::hex<<(u64)ptr<<std::dec<<";\n"; std::cout<<" delete 0x"<<std::hex<<(u64)ptr<<std::dec<<";\n";
std::cout<<"}\n"; std::cout<<"}\n";
} }
var create_new_ghost(var* args, usize size, gc* ngc) { var create_new_ghost(var* args, usize size, gc* ngc) {
var res=ngc->alloc(vm_obj); var res=ngc->alloc(vm_obj);
res.obj().set(ghost_for_test, new u32, &ngc->global_ghost_type_table); res.obj().set(ghost_for_test, new u32, &ngc->global_ghost_type_table);
return res; return res;
} }
var set_new_ghost(var* args, usize size, gc* ngc) { var set_new_ghost(var* args, usize size, gc* ngc) {
var res=args[0]; var res=args[0];
if (!res.objchk(ghost_for_test)) { if (!res.objchk(ghost_for_test)) {
std::cout<<"set_new_ghost: not ghost for test type.\n"; std::cout<<"set_new_ghost: not ghost for test type.\n";
return nil; return nil;
} }
f64 num=args[1].num(); f64 num=args[1].num();
*((u32*)res.obj().ptr)=static_cast<u32>(num); *((u32*)res.obj().ptr)=static_cast<u32>(num);
std::cout<<"set_new_ghost: successfully set ghost = "<<num<<"\n"; std::cout<<"set_new_ghost: successfully set ghost = "<<num<<"\n";
return nil; return nil;
} }
var print_new_ghost(var* args, usize size, gc* ngc) { var print_new_ghost(var* args, usize size, gc* ngc) {
var res=args[0]; var res=args[0];
if (!res.objchk(ghost_for_test)) { if (!res.objchk(ghost_for_test)) {
std::cout<<"print_new_ghost: not ghost for test type.\n"; std::cout<<"print_new_ghost: not ghost for test type.\n";
return nil; return nil;
} }
std::cout<<"print_new_ghost: "<<res.obj()<<" result = "<<*((u32*)res.obj().ptr)<<"\n"; std::cout<<"print_new_ghost: "<<res.obj()<<" result = "<<*((u32*)res.obj().ptr)<<"\n";
return nil; return nil;
} }
module_func_info func_tbl[]={ module_func_info func_tbl[]={
{"fib", fib}, {"fib", fib},
{"quick_fib", quick_fib}, {"quick_fib", quick_fib},
{"create_ghost", create_new_ghost}, {"create_ghost", create_new_ghost},
{"set_ghost", set_new_ghost}, {"set_ghost", set_new_ghost},
{"print_ghost", print_new_ghost}, {"print_ghost", print_new_ghost},
{nullptr, nullptr} {nullptr, nullptr}
}; };
} }
extern "C" module_func_info* get(ghost_register_table* table) { extern "C" module_func_info* get(ghost_register_table* table) {
if (table->exists("fib_for_test")) { if (table->exists("fib_for_test")) {
nasal_fib_module::ghost_for_test=table->get_ghost_type_index("fib_for_test"); nasal_fib_module::ghost_for_test=table->get_ghost_type_index("fib_for_test");
return nasal_fib_module::func_tbl; return nasal_fib_module::func_tbl;
} }
nasal_fib_module::ghost_for_test=table->register_ghost_type( nasal_fib_module::ghost_for_test=table->register_ghost_type(
"fib_for_test", "fib_for_test",
nasal_fib_module::ghost_for_test_destructor nasal_fib_module::ghost_for_test_destructor
); );
return nasal_fib_module::func_tbl; return nasal_fib_module::func_tbl;
} }

202
module/keyboard.cpp
View File

@ -1,100 +1,104 @@
#include "../nasal.h" #include "../nasal.h"
#include <unistd.h> #include <iostream>
#include <iostream>
#ifdef _WIN32 #ifndef _MSC_VER
#include <conio.h> #include <unistd.h>
#else #endif
#include <fcntl.h>
#include <termios.h> #ifdef _WIN32
#endif #include <conio.h>
#else
class noecho_input { #include <fcntl.h>
private: #include <termios.h>
#ifndef _WIN32 #endif
struct termios init_termios;
struct termios new_termios; class noecho_input {
int peek_char=-1; private:
#endif #ifndef _WIN32
public: struct termios init_termios;
noecho_input() { struct termios new_termios;
#ifndef _WIN32 int peek_char=-1;
tcflush(0, TCIOFLUSH); #endif
tcgetattr(0, &init_termios); public:
new_termios=init_termios; noecho_input() {
new_termios.c_lflag&=~(ICANON|ECHO|ECHONL|ECHOE); #ifndef _WIN32
// vmin=0 is nonblock input, but in wsl there is a bug that will block input tcflush(0, TCIOFLUSH);
// so we use fcntl to write the nonblock input tcgetattr(0, &init_termios);
new_termios.c_cc[VMIN]=1; new_termios=init_termios;
new_termios.c_cc[VTIME]=0; new_termios.c_lflag&=~(ICANON|ECHO|ECHONL|ECHOE);
tcsetattr(0, TCSANOW, &new_termios); // vmin=0 is nonblock input, but in wsl there is a bug that will block input
#endif // so we use fcntl to write the nonblock input
} new_termios.c_cc[VMIN]=1;
~noecho_input() { new_termios.c_cc[VTIME]=0;
#ifndef _WIN32 tcsetattr(0, TCSANOW, &new_termios);
tcflush(0, TCIOFLUSH); #endif
tcsetattr(0, TCSANOW, &init_termios); }
#endif ~noecho_input() {
} #ifndef _WIN32
int noecho_kbhit() { tcflush(0, TCIOFLUSH);
#ifndef _WIN32 tcsetattr(0, TCSANOW, &init_termios);
unsigned char ch=0; #endif
int nread=0; }
if (peek_char!=-1) { int noecho_kbhit() {
return 1; #ifndef _WIN32
} unsigned char ch=0;
int flag=fcntl(0, F_GETFL); int nread=0;
fcntl(0, F_SETFL,flag|O_NONBLOCK); if (peek_char!=-1) {
nread=read(0, &ch, 1); return 1;
fcntl(0, F_SETFL, flag); }
if (nread==1) { int flag=fcntl(0, F_GETFL);
peek_char=ch; fcntl(0, F_SETFL,flag|O_NONBLOCK);
return 1; nread=read(0, &ch, 1);
} fcntl(0, F_SETFL, flag);
return 0; if (nread==1) {
#else peek_char=ch;
return kbhit(); return 1;
#endif }
} return 0;
int noecho_getch() { #else
#ifndef _WIN32 return kbhit();
int ch=0; #endif
if (peek_char!=-1) { }
ch=peek_char; int noecho_getch() {
peek_char=-1; #ifndef _WIN32
return ch; int ch=0;
} if (peek_char!=-1) {
ssize_t tmp=read(0, &ch, 1); ch=peek_char;
return ch; peek_char=-1;
#else return ch;
return getch(); }
#endif ssize_t tmp=read(0, &ch, 1);
} return ch;
}; #else
return getch();
noecho_input this_window; #endif
}
var nas_getch(var* args, usize size, gc* ngc) { };
return var::num((double)this_window.noecho_getch());
} noecho_input this_window;
var nas_kbhit(var* args, usize size, gc* ngc) { var nas_getch(var* args, usize size, gc* ngc) {
return var::num((double)this_window.noecho_kbhit()); return var::num((double)this_window.noecho_getch());
} }
var nas_noblock(var* args, usize size, gc* ngc) { var nas_kbhit(var* args, usize size, gc* ngc) {
if (this_window.noecho_kbhit()) { return var::num((double)this_window.noecho_kbhit());
return var::num((double)this_window.noecho_getch()); }
}
return nil; var nas_noblock(var* args, usize size, gc* ngc) {
} if (this_window.noecho_kbhit()) {
return var::num((double)this_window.noecho_getch());
module_func_info func_tbl[]={ }
{"nas_getch",nas_getch}, return nil;
{"nas_kbhit",nas_kbhit}, }
{"nas_noblock",nas_noblock},
{nullptr,nullptr} module_func_info func_tbl[]={
}; {"nas_getch",nas_getch},
{"nas_kbhit",nas_kbhit},
extern "C" module_func_info* get(ghost_register_table* table) { {"nas_noblock",nas_noblock},
return func_tbl; {nullptr,nullptr}
};
extern "C" module_func_info* get(ghost_register_table* table) {
return func_tbl;
} }

590
module/matrix.cpp
View File

@ -1,296 +1,296 @@
#include "../nasal.h" #include "../nasal.h"
#include <cmath> #include <cmath>
var nas_vec2(var* args, usize size, gc* ngc) { var nas_vec2(var* args, usize size, gc* ngc) {
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(args[0]); res.vec().elems.push_back(args[0]);
res.vec().elems.push_back(args[1]); res.vec().elems.push_back(args[1]);
return res; return res;
} }
var nas_vec3(var* args, usize size, gc* ngc) { var nas_vec3(var* args, usize size, gc* ngc) {
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(args[0]); res.vec().elems.push_back(args[0]);
res.vec().elems.push_back(args[1]); res.vec().elems.push_back(args[1]);
res.vec().elems.push_back(args[2]); res.vec().elems.push_back(args[2]);
return res; return res;
} }
var nas_vec2_add(var* args, usize size, gc* ngc) { var nas_vec2_add(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec || args[1].type!=vm_vec) if (args[0].type!=vm_vec || args[1].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
auto& v1=args[1].vec().elems; auto& v1=args[1].vec().elems;
if (v0.size()!=2 || v1.size()!=2) if (v0.size()!=2 || v1.size()!=2)
return nil; return nil;
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num()+v1[0].num())); res.vec().elems.push_back(var::num(v0[0].num()+v1[0].num()));
res.vec().elems.push_back(var::num(v0[1].num()+v1[1].num())); res.vec().elems.push_back(var::num(v0[1].num()+v1[1].num()));
return res; return res;
} }
var nas_vec2_sub(var* args, usize size, gc* ngc) { var nas_vec2_sub(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec || args[1].type!=vm_vec) if (args[0].type!=vm_vec || args[1].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
auto& v1=args[1].vec().elems; auto& v1=args[1].vec().elems;
if (v0.size()!=2 || v1.size()!=2) if (v0.size()!=2 || v1.size()!=2)
return nil; return nil;
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num()-v1[0].num())); res.vec().elems.push_back(var::num(v0[0].num()-v1[0].num()));
res.vec().elems.push_back(var::num(v0[1].num()-v1[1].num())); res.vec().elems.push_back(var::num(v0[1].num()-v1[1].num()));
return res; return res;
} }
var nas_vec2_mult(var* args, usize size, gc* ngc) { var nas_vec2_mult(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec || args[1].type!=vm_vec) if (args[0].type!=vm_vec || args[1].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
auto& v1=args[1].vec().elems; auto& v1=args[1].vec().elems;
if (v0.size()!=2 || v1.size()!=2) if (v0.size()!=2 || v1.size()!=2)
return nil; return nil;
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num()*v1[0].num())); res.vec().elems.push_back(var::num(v0[0].num()*v1[0].num()));
res.vec().elems.push_back(var::num(v0[1].num()*v1[1].num())); res.vec().elems.push_back(var::num(v0[1].num()*v1[1].num()));
return res; return res;
} }
var nas_vec2_div(var* args, usize size, gc* ngc) { var nas_vec2_div(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec || args[1].type!=vm_vec) if (args[0].type!=vm_vec || args[1].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
auto& v1=args[1].vec().elems; auto& v1=args[1].vec().elems;
if (v0.size()!=2 || v1.size()!=2) if (v0.size()!=2 || v1.size()!=2)
return nil; return nil;
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num()/v1[0].num())); res.vec().elems.push_back(var::num(v0[0].num()/v1[0].num()));
res.vec().elems.push_back(var::num(v0[1].num()/v1[1].num())); res.vec().elems.push_back(var::num(v0[1].num()/v1[1].num()));
return res; return res;
} }
var nas_vec2_neg(var* args, usize size, gc* ngc) { var nas_vec2_neg(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec) if (args[0].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
if (v0.size()!=2) if (v0.size()!=2)
return nil; return nil;
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(-v0[0].num())); res.vec().elems.push_back(var::num(-v0[0].num()));
res.vec().elems.push_back(var::num(-v0[1].num())); res.vec().elems.push_back(var::num(-v0[1].num()));
return res; return res;
} }
var nas_vec2_norm(var* args, usize size, gc* ngc) { var nas_vec2_norm(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec) if (args[0].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
if (v0.size()!=2) if (v0.size()!=2)
return nil; return nil;
auto x=v0[0].num(); auto x=v0[0].num();
auto y=v0[1].num(); auto y=v0[1].num();
auto t=std::sqrt(x*x+y*y); auto t=std::sqrt(x*x+y*y);
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(x/t)); res.vec().elems.push_back(var::num(x/t));
res.vec().elems.push_back(var::num(y/t)); res.vec().elems.push_back(var::num(y/t));
return res; return res;
} }
var nas_vec2_len(var* args, usize size, gc* ngc) { var nas_vec2_len(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec) if (args[0].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
if (v0.size()!=2) if (v0.size()!=2)
return nil; return nil;
auto x=v0[0].num(); auto x=v0[0].num();
auto y=v0[1].num(); auto y=v0[1].num();
return var::num(std::sqrt(x*x+y*y)); return var::num(std::sqrt(x*x+y*y));
} }
var nas_vec2_dot(var* args, usize size, gc* ngc) { var nas_vec2_dot(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec || args[1].type!=vm_vec) if (args[0].type!=vm_vec || args[1].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
auto& v1=args[1].vec().elems; auto& v1=args[1].vec().elems;
if (v0.size()!=2 || v1.size()!=2) if (v0.size()!=2 || v1.size()!=2)
return nil; return nil;
return var::num(v0[0].num()*v1[0].num()+v0[1].num()*v1[1].num()); return var::num(v0[0].num()*v1[0].num()+v0[1].num()*v1[1].num());
} }
var nas_vec3_add(var* args, usize size, gc* ngc) { var nas_vec3_add(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec || args[1].type!=vm_vec) if (args[0].type!=vm_vec || args[1].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
auto& v1=args[1].vec().elems; auto& v1=args[1].vec().elems;
if (v0.size()!=3 || v1.size()!=3) if (v0.size()!=3 || v1.size()!=3)
return nil; return nil;
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num()+v1[0].num())); res.vec().elems.push_back(var::num(v0[0].num()+v1[0].num()));
res.vec().elems.push_back(var::num(v0[1].num()+v1[1].num())); res.vec().elems.push_back(var::num(v0[1].num()+v1[1].num()));
res.vec().elems.push_back(var::num(v0[2].num()+v1[2].num())); res.vec().elems.push_back(var::num(v0[2].num()+v1[2].num()));
return res; return res;
} }
var nas_vec3_sub(var* args, usize size, gc* ngc) { var nas_vec3_sub(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec || args[1].type!=vm_vec) if (args[0].type!=vm_vec || args[1].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
auto& v1=args[1].vec().elems; auto& v1=args[1].vec().elems;
if (v0.size()!=3 || v1.size()!=3) if (v0.size()!=3 || v1.size()!=3)
return nil; return nil;
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num()-v1[0].num())); res.vec().elems.push_back(var::num(v0[0].num()-v1[0].num()));
res.vec().elems.push_back(var::num(v0[1].num()-v1[1].num())); res.vec().elems.push_back(var::num(v0[1].num()-v1[1].num()));
res.vec().elems.push_back(var::num(v0[2].num()-v1[2].num())); res.vec().elems.push_back(var::num(v0[2].num()-v1[2].num()));
return res; return res;
} }
var nas_vec3_mult(var* args, usize size, gc* ngc) { var nas_vec3_mult(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec || args[1].type!=vm_vec) if (args[0].type!=vm_vec || args[1].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
auto& v1=args[1].vec().elems; auto& v1=args[1].vec().elems;
if (v0.size()!=3 || v1.size()!=3) if (v0.size()!=3 || v1.size()!=3)
return nil; return nil;
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num()*v1[0].num())); res.vec().elems.push_back(var::num(v0[0].num()*v1[0].num()));
res.vec().elems.push_back(var::num(v0[1].num()*v1[1].num())); res.vec().elems.push_back(var::num(v0[1].num()*v1[1].num()));
res.vec().elems.push_back(var::num(v0[2].num()*v1[2].num())); res.vec().elems.push_back(var::num(v0[2].num()*v1[2].num()));
return res; return res;
} }
var nas_vec3_div(var* args, usize size, gc* ngc) { var nas_vec3_div(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec || args[1].type!=vm_vec) if (args[0].type!=vm_vec || args[1].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
auto& v1=args[1].vec().elems; auto& v1=args[1].vec().elems;
if (v0.size()!=3 || v1.size()!=3) if (v0.size()!=3 || v1.size()!=3)
return nil; return nil;
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num()/v1[0].num())); res.vec().elems.push_back(var::num(v0[0].num()/v1[0].num()));
res.vec().elems.push_back(var::num(v0[1].num()/v1[1].num())); res.vec().elems.push_back(var::num(v0[1].num()/v1[1].num()));
res.vec().elems.push_back(var::num(v0[2].num()/v1[2].num())); res.vec().elems.push_back(var::num(v0[2].num()/v1[2].num()));
return res; return res;
} }
var nas_vec3_neg(var* args, usize size, gc* ngc) { var nas_vec3_neg(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec) if (args[0].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
if (v0.size()!=3) if (v0.size()!=3)
return nil; return nil;
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(-v0[0].num())); res.vec().elems.push_back(var::num(-v0[0].num()));
res.vec().elems.push_back(var::num(-v0[1].num())); res.vec().elems.push_back(var::num(-v0[1].num()));
res.vec().elems.push_back(var::num(-v0[2].num())); res.vec().elems.push_back(var::num(-v0[2].num()));
return res; return res;
} }
var nas_vec3_norm(var* args, usize size, gc* ngc) { var nas_vec3_norm(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec) if (args[0].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
if (v0.size()!=3) if (v0.size()!=3)
return nil; return nil;
auto x=v0[0].num(); auto x=v0[0].num();
auto y=v0[1].num(); auto y=v0[1].num();
auto z=v0[2].num(); auto z=v0[2].num();
auto t=std::sqrt(x*x+y*y+z*z); auto t=std::sqrt(x*x+y*y+z*z);
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(x/t)); res.vec().elems.push_back(var::num(x/t));
res.vec().elems.push_back(var::num(y/t)); res.vec().elems.push_back(var::num(y/t));
res.vec().elems.push_back(var::num(z/t)); res.vec().elems.push_back(var::num(z/t));
return res; return res;
} }
var nas_vec3_len(var* args, usize size, gc* ngc) { var nas_vec3_len(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec) if (args[0].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
if (v0.size()!=3) if (v0.size()!=3)
return nil; return nil;
auto x=v0[0].num(); auto x=v0[0].num();
auto y=v0[1].num(); auto y=v0[1].num();
auto z=v0[2].num(); auto z=v0[2].num();
return var::num(std::sqrt(x*x+y*y+z*z)); return var::num(std::sqrt(x*x+y*y+z*z));
} }
var nas_rotate_x(var* args, usize size, gc* ngc) { var nas_rotate_x(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec) if (args[0].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
if (v0.size()!=3) if (v0.size()!=3)
return nil; return nil;
auto angle=args[1].num(); auto angle=args[1].num();
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num())); res.vec().elems.push_back(var::num(v0[0].num()));
res.vec().elems.push_back(var::num(v0[2].num()*std::sin(angle)+v0[1].num()*std::cos(angle))); res.vec().elems.push_back(var::num(v0[2].num()*std::sin(angle)+v0[1].num()*std::cos(angle)));
res.vec().elems.push_back(var::num(v0[2].num()*std::cos(angle)-v0[1].num()*std::sin(angle))); res.vec().elems.push_back(var::num(v0[2].num()*std::cos(angle)-v0[1].num()*std::sin(angle)));
return res; return res;
} }
var nas_rotate_y(var* args, usize size, gc* ngc) { var nas_rotate_y(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec) if (args[0].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
if (v0.size()!=3) if (v0.size()!=3)
return nil; return nil;
auto angle=args[1].num(); auto angle=args[1].num();
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num()*std::cos(angle)-v0[2].num()*std::sin(angle))); res.vec().elems.push_back(var::num(v0[0].num()*std::cos(angle)-v0[2].num()*std::sin(angle)));
res.vec().elems.push_back(var::num(v0[1].num())); res.vec().elems.push_back(var::num(v0[1].num()));
res.vec().elems.push_back(var::num(v0[0].num()*std::sin(angle)+v0[2].num()*std::cos(angle))); res.vec().elems.push_back(var::num(v0[0].num()*std::sin(angle)+v0[2].num()*std::cos(angle)));
return res; return res;
} }
var nas_rotate_z(var* args, usize size, gc* ngc) { var nas_rotate_z(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec) if (args[0].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
if (v0.size()!=3) if (v0.size()!=3)
return nil; return nil;
auto angle=args[1].num(); auto angle=args[1].num();
var res=ngc->alloc(vm_vec); var res=ngc->alloc(vm_vec);
res.vec().elems.push_back(var::num(v0[0].num()*std::cos(angle)-v0[1].num()*std::sin(angle))); res.vec().elems.push_back(var::num(v0[0].num()*std::cos(angle)-v0[1].num()*std::sin(angle)));
res.vec().elems.push_back(var::num(v0[0].num()*std::sin(angle)+v0[1].num()*std::cos(angle))); res.vec().elems.push_back(var::num(v0[0].num()*std::sin(angle)+v0[1].num()*std::cos(angle)));
res.vec().elems.push_back(var::num(v0[2].num())); res.vec().elems.push_back(var::num(v0[2].num()));
return res; return res;
} }
var nas_vec3_dot(var* args, usize size, gc* ngc) { var nas_vec3_dot(var* args, usize size, gc* ngc) {
if (args[0].type!=vm_vec || args[1].type!=vm_vec) if (args[0].type!=vm_vec || args[1].type!=vm_vec)
return nil; return nil;
auto& v0=args[0].vec().elems; auto& v0=args[0].vec().elems;
auto& v1=args[1].vec().elems; auto& v1=args[1].vec().elems;
if (v0.size()!=3 || v1.size()!=3) if (v0.size()!=3 || v1.size()!=3)
return nil; return nil;
return var::num(v0[0].num()*v1[0].num()+v0[1].num()*v1[1].num()+v0[2].num()*v1[2].num()); return var::num(v0[0].num()*v1[0].num()+v0[1].num()*v1[1].num()+v0[2].num()*v1[2].num());
} }
module_func_info func_tbl[]={ module_func_info func_tbl[]={
{"nas_vec2",nas_vec2}, {"nas_vec2",nas_vec2},
{"nas_vec2_add",nas_vec2_add}, {"nas_vec2_add",nas_vec2_add},
{"nas_vec2_sub",nas_vec2_sub}, {"nas_vec2_sub",nas_vec2_sub},
{"nas_vec2_mult",nas_vec2_mult}, {"nas_vec2_mult",nas_vec2_mult},
{"nas_vec2_div",nas_vec2_div}, {"nas_vec2_div",nas_vec2_div},
{"nas_vec2_neg",nas_vec2_neg}, {"nas_vec2_neg",nas_vec2_neg},
{"nas_vec2_norm",nas_vec2_norm}, {"nas_vec2_norm",nas_vec2_norm},
{"nas_vec2_len",nas_vec2_len}, {"nas_vec2_len",nas_vec2_len},
{"nas_vec2_dot",nas_vec2_dot}, {"nas_vec2_dot",nas_vec2_dot},
{"nas_vec3",nas_vec3}, {"nas_vec3",nas_vec3},
{"nas_vec3_add",nas_vec3_add}, {"nas_vec3_add",nas_vec3_add},
{"nas_vec3_sub",nas_vec3_sub}, {"nas_vec3_sub",nas_vec3_sub},
{"nas_vec3_mult",nas_vec3_mult}, {"nas_vec3_mult",nas_vec3_mult},
{"nas_vec3_div",nas_vec3_div}, {"nas_vec3_div",nas_vec3_div},
{"nas_vec3_neg",nas_vec3_neg}, {"nas_vec3_neg",nas_vec3_neg},
{"nas_vec3_norm",nas_vec3_norm}, {"nas_vec3_norm",nas_vec3_norm},
{"nas_vec3_len",nas_vec3_len}, {"nas_vec3_len",nas_vec3_len},
{"nas_rotate_x",nas_rotate_x}, {"nas_rotate_x",nas_rotate_x},
{"nas_rotate_y",nas_rotate_y}, {"nas_rotate_y",nas_rotate_y},
{"nas_rotate_z",nas_rotate_z}, {"nas_rotate_z",nas_rotate_z},
{"nas_vec3_dot",nas_vec3_dot}, {"nas_vec3_dot",nas_vec3_dot},
{nullptr,nullptr} {nullptr,nullptr}
}; };
extern "C" module_func_info* get(ghost_register_table* table) { extern "C" module_func_info* get(ghost_register_table* table) {
return func_tbl; return func_tbl;
} }

423
module/nasocket.cpp
View File

@ -1,211 +1,214 @@
#include "../nasal.h" #include "../nasal.h"
#include <unistd.h>
#ifndef _MSC_VER
#ifdef _WIN32 #include <unistd.h>
#include <winsock.h> #endif
#pragma comment(lib,"ws2_32")
#ifdef _WIN32
class WSAmanager{ #include <winsock.h>
private: #pragma comment(lib,"ws2_32")
WSAData data;
public: class WSAmanager{
WSAmanager() { private:
WSAStartup(0x1010, &data); WSAData data;
} public:
~WSAmanager() { WSAmanager() {
WSACleanup(); WSAStartup(0x1010, &data);
} }
}; ~WSAmanager() {
WSACleanup();
static WSAmanager win; }
#else };
#include <netdb.h>
#include <sys/socket.h> static WSAmanager win;
#include <arpa/inet.h> #else
#include <netinet/in.h> #include <netdb.h>
#endif #include <sys/socket.h>
#include <arpa/inet.h>
var nas_socket(var* args, usize size, gc* ngc) { #include <netinet/in.h>
if (args[0].type!=vm_num || args[1].type!=vm_num || args[2].type!=vm_num) #endif
return nas_err("socket","\"af\", \"type\", \"protocol\" should be number");
int sd=socket(args[0].num(),args[1].num(),args[2].num()); var nas_socket(var* args, usize size, gc* ngc) {
return var::num((double)sd); if (args[0].type!=vm_num || args[1].type!=vm_num || args[2].type!=vm_num)
} return nas_err("socket","\"af\", \"type\", \"protocol\" should be number");
int sd=socket(args[0].num(),args[1].num(),args[2].num());
var nas_closesocket(var* args, usize size, gc* ngc) { return var::num((double)sd);
if (args[0].type!=vm_num) }
return nas_err("closesocket","\"sd\" should be number");
#ifdef _WIN32 var nas_closesocket(var* args, usize size, gc* ngc) {
return var::num((double)closesocket(args[0].num())); if (args[0].type!=vm_num)
#else return nas_err("closesocket","\"sd\" should be number");
return var::num((double)close(args[0].num())); #ifdef _WIN32
#endif return var::num((double)closesocket(args[0].num()));
} #else
return var::num((double)close(args[0].num()));
var nas_shutdown(var* args, usize size, gc* ngc) { #endif
if (args[0].type!=vm_num) }
return nas_err("shutdown","\"sd\" must be a number");
if (args[1].type!=vm_num) var nas_shutdown(var* args, usize size, gc* ngc) {
return nas_err("shutdown","\"how\" must be a number"); if (args[0].type!=vm_num)
return var::num((double)shutdown(args[0].num(),args[1].num())); return nas_err("shutdown","\"sd\" must be a number");
} if (args[1].type!=vm_num)
return nas_err("shutdown","\"how\" must be a number");
var nas_bind(var* args, usize size, gc* ngc) { return var::num((double)shutdown(args[0].num(),args[1].num()));
if (args[0].type!=vm_num) }
return nas_err("bind","\"sd\" muse be a number");
if (args[1].type!=vm_str) var nas_bind(var* args, usize size, gc* ngc) {
return nas_err("bind","\"ip\" should be a string including an ip with correct format"); if (args[0].type!=vm_num)
if (args[2].type!=vm_num) return nas_err("bind","\"sd\" muse be a number");
return nas_err("bind","\"port\" must be a number"); if (args[1].type!=vm_str)
sockaddr_in server; return nas_err("bind","\"ip\" should be a string including an ip with correct format");
memset(&server,0,sizeof(sockaddr_in)); if (args[2].type!=vm_num)
server.sin_family=AF_INET; return nas_err("bind","\"port\" must be a number");
server.sin_addr.s_addr=inet_addr(args[1].str().c_str()); sockaddr_in server;
server.sin_port=htons(args[2].num()); memset(&server,0,sizeof(sockaddr_in));
return var::num((double)bind(args[0].num(),(sockaddr*)&server,sizeof(server))); server.sin_family=AF_INET;
} server.sin_addr.s_addr=inet_addr(args[1].str().c_str());
server.sin_port=htons(args[2].num());
var nas_listen(var* args, usize size, gc* ngc) { return var::num((double)bind(args[0].num(),(sockaddr*)&server,sizeof(server)));
if (args[0].type!=vm_num) }
return nas_err("listen","\"sd\" must be a number");
if (args[1].type!=vm_num) var nas_listen(var* args, usize size, gc* ngc) {
return nas_err("listen","\"backlog\" must be a number"); if (args[0].type!=vm_num)
return var::num((double)listen(args[0].num(),args[1].num())); return nas_err("listen","\"sd\" must be a number");
} if (args[1].type!=vm_num)
return nas_err("listen","\"backlog\" must be a number");
var nas_connect(var* args, usize size, gc* ngc) { return var::num((double)listen(args[0].num(),args[1].num()));
if (args[0].type!=vm_num) }
return nas_err("connect","\"sd\" must be a number");
if (args[1].type!=vm_str) var nas_connect(var* args, usize size, gc* ngc) {
return nas_err("connect","\"hostname\" must be a string"); if (args[0].type!=vm_num)
if (args[2].type!=vm_num) return nas_err("connect","\"sd\" must be a number");
return nas_err("connect","\"port\" must be a number"); if (args[1].type!=vm_str)
sockaddr_in addr; return nas_err("connect","\"hostname\" must be a string");
memset(&addr,0,sizeof(sockaddr_in)); if (args[2].type!=vm_num)
addr.sin_family=AF_INET; return nas_err("connect","\"port\" must be a number");
addr.sin_port=htons(args[2].num()); sockaddr_in addr;
hostent* entry=gethostbyname(args[1].str().c_str()); memset(&addr,0,sizeof(sockaddr_in));
memcpy(&addr.sin_addr,entry->h_addr,entry->h_length); addr.sin_family=AF_INET;
return var::num((double)connect(args[0].num(),(sockaddr*)&addr,sizeof(sockaddr_in))); addr.sin_port=htons(args[2].num());
} hostent* entry=gethostbyname(args[1].str().c_str());
memcpy(&addr.sin_addr,entry->h_addr,entry->h_length);
var nas_accept(var* args, usize size, gc* ngc) { return var::num((double)connect(args[0].num(),(sockaddr*)&addr,sizeof(sockaddr_in)));
if (args[0].type!=vm_num) }
return nas_err("accept","\"sd\" must be a number");
sockaddr_in client; var nas_accept(var* args, usize size, gc* ngc) {
int socklen=sizeof(sockaddr_in); if (args[0].type!=vm_num)
#ifdef _WIN32 return nas_err("accept","\"sd\" must be a number");
int client_sd=accept(args[0].num(),(sockaddr*)&client,&socklen); sockaddr_in client;
#else int socklen=sizeof(sockaddr_in);
int client_sd=accept(args[0].num(),(sockaddr*)&client,(socklen_t*)&socklen); #ifdef _WIN32
#endif int client_sd=accept(args[0].num(),(sockaddr*)&client,&socklen);
var res=ngc->temp=ngc->alloc(vm_hash); #else
auto& hash=res.hash().elems; int client_sd=accept(args[0].num(),(sockaddr*)&client,(socklen_t*)&socklen);
hash["sd"]=var::num((double)client_sd); #endif
hash["ip"]=ngc->newstr(inet_ntoa(client.sin_addr)); var res=ngc->temp=ngc->alloc(vm_hash);
ngc->temp=nil; auto& hash=res.hash().elems;
return res; hash["sd"]=var::num((double)client_sd);
} hash["ip"]=ngc->newstr(inet_ntoa(client.sin_addr));
ngc->temp=nil;
var nas_send(var* args, usize size, gc* ngc) { return res;
if (args[0].type!=vm_num) }
return nas_err("send","\"sd\" must be a number");
if (args[1].type!=vm_str) var nas_send(var* args, usize size, gc* ngc) {
return nas_err("send","\"buff\" must be a string"); if (args[0].type!=vm_num)
if (args[2].type!=vm_num) return nas_err("send","\"sd\" must be a number");
return nas_err("send","\"flags\" muse be a number"); if (args[1].type!=vm_str)
return var::num((double)send(args[0].num(),args[1].str().c_str(),args[1].str().length(),args[2].num())); return nas_err("send","\"buff\" must be a string");
} if (args[2].type!=vm_num)
return nas_err("send","\"flags\" muse be a number");
var nas_sendto(var* args, usize size, gc* ngc) { return var::num((double)send(args[0].num(),args[1].str().c_str(),args[1].str().length(),args[2].num()));
if (args[0].type!=vm_num) }
return nas_err("sendto","\"sd\" must be a number");
if (args[1].type!=vm_str) var nas_sendto(var* args, usize size, gc* ngc) {
return nas_err("sendto","\"hostname\" must be a string"); if (args[0].type!=vm_num)
if (args[2].type!=vm_num) return nas_err("sendto","\"sd\" must be a number");
return nas_err("sendto","\"port\" must be a number"); if (args[1].type!=vm_str)
if (args[3].type!=vm_str) return nas_err("sendto","\"hostname\" must be a string");
return nas_err("sendto","\"buff\" must be a string"); if (args[2].type!=vm_num)
if (args[4].type!=vm_num) return nas_err("sendto","\"port\" must be a number");
return nas_err("sendto","\"flags\" must be a number"); if (args[3].type!=vm_str)
sockaddr_in addr; return nas_err("sendto","\"buff\" must be a string");
memset(&addr,0,sizeof(sockaddr_in)); if (args[4].type!=vm_num)
addr.sin_family=AF_INET; return nas_err("sendto","\"flags\" must be a number");
addr.sin_port=htons(args[2].num()); sockaddr_in addr;
hostent* entry=gethostbyname(args[1].str().c_str()); memset(&addr,0,sizeof(sockaddr_in));
memcpy(&addr.sin_addr,entry->h_addr,entry->h_length); addr.sin_family=AF_INET;
return var::num((double)sendto(args[0].num(),args[3].str().c_str(),args[3].str().length(),args[4].num(),(sockaddr*)&addr,sizeof(sockaddr_in))); addr.sin_port=htons(args[2].num());
} hostent* entry=gethostbyname(args[1].str().c_str());
memcpy(&addr.sin_addr,entry->h_addr,entry->h_length);
var nas_recv(var* args, usize size, gc* ngc) { return var::num((double)sendto(args[0].num(),args[3].str().c_str(),args[3].str().length(),args[4].num(),(sockaddr*)&addr,sizeof(sockaddr_in)));
if (args[0].type!=vm_num) }
return nas_err("recv","\"sd\" must be a number");
if (args[1].type!=vm_num) var nas_recv(var* args, usize size, gc* ngc) {
return nas_err("recv","\"len\" must be a number"); if (args[0].type!=vm_num)
if (args[1].num()<=0 || args[1].num()>16*1024*1024) return nas_err("recv","\"sd\" must be a number");
return nas_err("recv","\"len\" out of range"); if (args[1].type!=vm_num)
if (args[2].type!=vm_num) return nas_err("recv","\"len\" must be a number");
return nas_err("recv","\"flags\" muse be a number"); if (args[1].num()<=0 || args[1].num()>16*1024*1024)
var res=ngc->temp=ngc->alloc(vm_hash); return nas_err("recv","\"len\" out of range");
auto& hash=res.hash().elems; if (args[2].type!=vm_num)
char* buf=new char[(int)args[1].num()]; return nas_err("recv","\"flags\" muse be a number");
auto recvsize=recv(args[0].num(),buf,args[1].num(),args[2].num()); var res=ngc->temp=ngc->alloc(vm_hash);
hash["size"]=var::num((double)recvsize); auto& hash=res.hash().elems;
buf[recvsize>=0?recvsize:0]=0; char* buf=new char[(int)args[1].num()];
hash["str"]=ngc->newstr(buf); auto recvsize=recv(args[0].num(),buf,args[1].num(),args[2].num());
delete[] buf; hash["size"]=var::num((double)recvsize);
ngc->temp=nil; buf[recvsize>=0?recvsize:0]=0;
return res; hash["str"]=ngc->newstr(buf);
} delete[] buf;
ngc->temp=nil;
var nas_recvfrom(var* args, usize size, gc* ngc) { return res;
if (args[0].type!=vm_num) }
return nas_err("recvfrom","\"sd\" must be a number");
if (args[1].type!=vm_num) var nas_recvfrom(var* args, usize size, gc* ngc) {
return nas_err("recvfrom","\"len\" must be a number"); if (args[0].type!=vm_num)
if (args[1].num()<=0 || args[1].num()>16*1024*1024) return nas_err("recvfrom","\"sd\" must be a number");
return nas_err("recvfrom","\"len\" out of range"); if (args[1].type!=vm_num)
if (args[2].type!=vm_num) return nas_err("recvfrom","\"len\" must be a number");
return nas_err("recvfrom","\"flags\" muse be a number"); if (args[1].num()<=0 || args[1].num()>16*1024*1024)
sockaddr_in addr; return nas_err("recvfrom","\"len\" out of range");
int socklen=sizeof(sockaddr_in); if (args[2].type!=vm_num)
var res=ngc->temp=ngc->alloc(vm_hash); return nas_err("recvfrom","\"flags\" muse be a number");
auto& hash=res.hash().elems; sockaddr_in addr;
char* buf=new char[(int)args[1].num()+1]; int socklen=sizeof(sockaddr_in);
#ifdef _WIN32 var res=ngc->temp=ngc->alloc(vm_hash);
auto recvsize=recvfrom(args[0].num(),buf,args[1].num(),args[2].num(),(sockaddr*)&addr,&socklen); auto& hash=res.hash().elems;
#else char* buf=new char[(int)args[1].num()+1];
auto recvsize=recvfrom(args[0].num(),buf,args[1].num(),args[2].num(),(sockaddr*)&addr,(socklen_t*)&socklen); #ifdef _WIN32
#endif auto recvsize=recvfrom(args[0].num(),buf,args[1].num(),args[2].num(),(sockaddr*)&addr,&socklen);
hash["size"]=var::num((double)recvsize); #else
buf[recvsize>=0?recvsize:0]=0; auto recvsize=recvfrom(args[0].num(),buf,args[1].num(),args[2].num(),(sockaddr*)&addr,(socklen_t*)&socklen);
hash["str"]=ngc->newstr(buf); #endif
delete[] buf; hash["size"]=var::num((double)recvsize);
hash["fromip"]=ngc->newstr(inet_ntoa(addr.sin_addr)); buf[recvsize>=0?recvsize:0]=0;
ngc->temp=nil; hash["str"]=ngc->newstr(buf);
return res; delete[] buf;
} hash["fromip"]=ngc->newstr(inet_ntoa(addr.sin_addr));
ngc->temp=nil;
var nas_errno(var* args, usize size, gc* ngc) { return res;
return ngc->newstr(strerror(errno)); }
}
var nas_errno(var* args, usize size, gc* ngc) {
module_func_info func_tbl[]={ return ngc->newstr(strerror(errno));
{"nas_socket",nas_socket}, }
{"nas_closesocket",nas_closesocket},
{"nas_shutdown",nas_shutdown}, module_func_info func_tbl[]={
{"nas_bind",nas_bind}, {"nas_socket",nas_socket},
{"nas_listen",nas_listen}, {"nas_closesocket",nas_closesocket},
{"nas_connect",nas_connect}, {"nas_shutdown",nas_shutdown},
{"nas_accept",nas_accept}, {"nas_bind",nas_bind},
{"nas_send",nas_send}, {"nas_listen",nas_listen},
{"nas_sendto",nas_sendto}, {"nas_connect",nas_connect},
{"nas_recv",nas_recv}, {"nas_accept",nas_accept},
{"nas_recvfrom",nas_recvfrom}, {"nas_send",nas_send},
{"nas_errno",nas_errno}, {"nas_sendto",nas_sendto},
{nullptr,nullptr} {"nas_recv",nas_recv},
}; {"nas_recvfrom",nas_recvfrom},
{"nas_errno",nas_errno},
extern "C" module_func_info* get(ghost_register_table* table) { {nullptr,nullptr}
return func_tbl; };
extern "C" module_func_info* get(ghost_register_table* table) {
return func_tbl;
} }