🐛 fix header in module for vs to build
This commit is contained in:
ValKmjolnir
parent
d954a3fc5e
commit
dfb0c6ab52
196
module/fib.cpp
196
module/fib.cpp
|
|
@ -1,99 +1,99 @@
|
|||
// module for test
|
||||
|
||||
#include <iostream>
|
||||
#include "../nasal.h"
|
||||
|
||||
namespace nasal_fib_module {
|
||||
|
||||
double fibonaci(double x) {
|
||||
if (x<=2) {
|
||||
return x;
|
||||
}
|
||||
return fibonaci(x-1)+fibonaci(x-2);
|
||||
}
|
||||
|
||||
var fib(var* args, usize size, gc* ngc) {
|
||||
if (!size) {
|
||||
return nas_err("fib","lack arguments");
|
||||
}
|
||||
var num=args[0];
|
||||
return var::num(fibonaci(num.tonum()));
|
||||
}
|
||||
|
||||
var quick_fib(var* args, usize size, gc* ngc) {
|
||||
if (!size) {
|
||||
return nas_err("quick_fib","lack arguments");
|
||||
}
|
||||
double num=args[0].tonum();
|
||||
if (num<2) {
|
||||
return var::num(num);
|
||||
}
|
||||
double a=1,b=1,res=0;
|
||||
for(double i=1;i<num;i+=1) {
|
||||
res=a+b;
|
||||
a=b;
|
||||
b=res;
|
||||
}
|
||||
return var::num(res);
|
||||
}
|
||||
|
||||
u32 ghost_for_test;
|
||||
|
||||
void ghost_for_test_destructor(void* ptr) {
|
||||
std::cout<<"ghost_for_test::destructor (0x";
|
||||
std::cout<<std::hex<<(u64)ptr<<std::dec<<") {\n";
|
||||
delete (u32*)ptr;
|
||||
std::cout<<" delete 0x"<<std::hex<<(u64)ptr<<std::dec<<";\n";
|
||||
std::cout<<"}\n";
|
||||
}
|
||||
|
||||
var create_new_ghost(var* args, usize size, gc* ngc) {
|
||||
var res=ngc->alloc(vm_obj);
|
||||
res.obj().set(ghost_for_test, new u32, &ngc->global_ghost_type_table);
|
||||
return res;
|
||||
}
|
||||
|
||||
var set_new_ghost(var* args, usize size, gc* ngc) {
|
||||
var res=args[0];
|
||||
if (!res.objchk(ghost_for_test)) {
|
||||
std::cout<<"set_new_ghost: not ghost for test type.\n";
|
||||
return nil;
|
||||
}
|
||||
f64 num=args[1].num();
|
||||
*((u32*)res.obj().ptr)=static_cast<u32>(num);
|
||||
std::cout<<"set_new_ghost: successfully set ghost = "<<num<<"\n";
|
||||
return nil;
|
||||
}
|
||||
|
||||
var print_new_ghost(var* args, usize size, gc* ngc) {
|
||||
var res=args[0];
|
||||
if (!res.objchk(ghost_for_test)) {
|
||||
std::cout<<"print_new_ghost: not ghost for test type.\n";
|
||||
return nil;
|
||||
}
|
||||
std::cout<<"print_new_ghost: "<<res.obj()<<" result = "<<*((u32*)res.obj().ptr)<<"\n";
|
||||
return nil;
|
||||
}
|
||||
|
||||
module_func_info func_tbl[]={
|
||||
{"fib", fib},
|
||||
{"quick_fib", quick_fib},
|
||||
{"create_ghost", create_new_ghost},
|
||||
{"set_ghost", set_new_ghost},
|
||||
{"print_ghost", print_new_ghost},
|
||||
{nullptr, nullptr}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
extern "C" module_func_info* get(ghost_register_table* table) {
|
||||
if (table->exists("fib_for_test")) {
|
||||
nasal_fib_module::ghost_for_test=table->get_ghost_type_index("fib_for_test");
|
||||
return nasal_fib_module::func_tbl;
|
||||
}
|
||||
nasal_fib_module::ghost_for_test=table->register_ghost_type(
|
||||
"fib_for_test",
|
||||
nasal_fib_module::ghost_for_test_destructor
|
||||
);
|
||||
return nasal_fib_module::func_tbl;
|
||||
// module for test
|
||||
|
||||
#include <iostream>
|
||||
#include "../nasal.h"
|
||||
|
||||
namespace nasal_fib_module {
|
||||
|
||||
double fibonaci(double x) {
|
||||
if (x<=2) {
|
||||
return x;
|
||||
}
|
||||
return fibonaci(x-1)+fibonaci(x-2);
|
||||
}
|
||||
|
||||
var fib(var* args, usize size, gc* ngc) {
|
||||
if (!size) {
|
||||
return nas_err("fib","lack arguments");
|
||||
}
|
||||
var num=args[0];
|
||||
return var::num(fibonaci(num.tonum()));
|
||||
}
|
||||
|
||||
var quick_fib(var* args, usize size, gc* ngc) {
|
||||
if (!size) {
|
||||
return nas_err("quick_fib","lack arguments");
|
||||
}
|
||||
double num=args[0].tonum();
|
||||
if (num<2) {
|
||||
return var::num(num);
|
||||
}
|
||||
double a=1,b=1,res=0;
|
||||
for(double i=1;i<num;i+=1) {
|
||||
res=a+b;
|
||||
a=b;
|
||||
b=res;
|
||||
}
|
||||
return var::num(res);
|
||||
}
|
||||
|
||||
u32 ghost_for_test;
|
||||
|
||||
void ghost_for_test_destructor(void* ptr) {
|
||||
std::cout<<"ghost_for_test::destructor (0x";
|
||||
std::cout<<std::hex<<(u64)ptr<<std::dec<<") {\n";
|
||||
delete (u32*)ptr;
|
||||
std::cout<<" delete 0x"<<std::hex<<(u64)ptr<<std::dec<<";\n";
|
||||
std::cout<<"}\n";
|
||||
}
|
||||
|
||||
var create_new_ghost(var* args, usize size, gc* ngc) {
|
||||
var res=ngc->alloc(vm_obj);
|
||||
res.obj().set(ghost_for_test, new u32, &ngc->global_ghost_type_table);
|
||||
return res;
|
||||
}
|
||||
|
||||
var set_new_ghost(var* args, usize size, gc* ngc) {
|
||||
var res=args[0];
|
||||
if (!res.objchk(ghost_for_test)) {
|
||||
std::cout<<"set_new_ghost: not ghost for test type.\n";
|
||||
return nil;
|
||||
}
|
||||
f64 num=args[1].num();
|
||||
*((u32*)res.obj().ptr)=static_cast<u32>(num);
|
||||
std::cout<<"set_new_ghost: successfully set ghost = "<<num<<"\n";
|
||||
return nil;
|
||||
}
|
||||
|
||||
var print_new_ghost(var* args, usize size, gc* ngc) {
|
||||
var res=args[0];
|
||||
if (!res.objchk(ghost_for_test)) {
|
||||
std::cout<<"print_new_ghost: not ghost for test type.\n";
|
||||
return nil;
|
||||
}
|
||||
std::cout<<"print_new_ghost: "<<res.obj()<<" result = "<<*((u32*)res.obj().ptr)<<"\n";
|
||||
return nil;
|
||||
}
|
||||
|
||||
module_func_info func_tbl[]={
|
||||
{"fib", fib},
|
||||
{"quick_fib", quick_fib},
|
||||
{"create_ghost", create_new_ghost},
|
||||
{"set_ghost", set_new_ghost},
|
||||
{"print_ghost", print_new_ghost},
|
||||
{nullptr, nullptr}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
extern "C" module_func_info* get(ghost_register_table* table) {
|
||||
if (table->exists("fib_for_test")) {
|
||||
nasal_fib_module::ghost_for_test=table->get_ghost_type_index("fib_for_test");
|
||||
return nasal_fib_module::func_tbl;
|
||||
}
|
||||
nasal_fib_module::ghost_for_test=table->register_ghost_type(
|
||||
"fib_for_test",
|
||||
nasal_fib_module::ghost_for_test_destructor
|
||||
);
|
||||
return nasal_fib_module::func_tbl;
|
||||
}
|
||||
|
|
@ -1,100 +1,104 @@
|
|||
#include "../nasal.h"
|
||||
#include <unistd.h>
|
||||
#include <iostream>
|
||||
#ifdef _WIN32
|
||||
#include <conio.h>
|
||||
#else
|
||||
#include <fcntl.h>
|
||||
#include <termios.h>
|
||||
#endif
|
||||
|
||||
class noecho_input {
|
||||
private:
|
||||
#ifndef _WIN32
|
||||
struct termios init_termios;
|
||||
struct termios new_termios;
|
||||
int peek_char=-1;
|
||||
#endif
|
||||
public:
|
||||
noecho_input() {
|
||||
#ifndef _WIN32
|
||||
tcflush(0, TCIOFLUSH);
|
||||
tcgetattr(0, &init_termios);
|
||||
new_termios=init_termios;
|
||||
new_termios.c_lflag&=~(ICANON|ECHO|ECHONL|ECHOE);
|
||||
// vmin=0 is nonblock input, but in wsl there is a bug that will block input
|
||||
// so we use fcntl to write the nonblock input
|
||||
new_termios.c_cc[VMIN]=1;
|
||||
new_termios.c_cc[VTIME]=0;
|
||||
tcsetattr(0, TCSANOW, &new_termios);
|
||||
#endif
|
||||
}
|
||||
~noecho_input() {
|
||||
#ifndef _WIN32
|
||||
tcflush(0, TCIOFLUSH);
|
||||
tcsetattr(0, TCSANOW, &init_termios);
|
||||
#endif
|
||||
}
|
||||
int noecho_kbhit() {
|
||||
#ifndef _WIN32
|
||||
unsigned char ch=0;
|
||||
int nread=0;
|
||||
if (peek_char!=-1) {
|
||||
return 1;
|
||||
}
|
||||
int flag=fcntl(0, F_GETFL);
|
||||
fcntl(0, F_SETFL,flag|O_NONBLOCK);
|
||||
nread=read(0, &ch, 1);
|
||||
fcntl(0, F_SETFL, flag);
|
||||
if (nread==1) {
|
||||
peek_char=ch;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
#else
|
||||
return kbhit();
|
||||
#endif
|
||||
}
|
||||
int noecho_getch() {
|
||||
#ifndef _WIN32
|
||||
int ch=0;
|
||||
if (peek_char!=-1) {
|
||||
ch=peek_char;
|
||||
peek_char=-1;
|
||||
return ch;
|
||||
}
|
||||
ssize_t tmp=read(0, &ch, 1);
|
||||
return ch;
|
||||
#else
|
||||
return getch();
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
noecho_input this_window;
|
||||
|
||||
var nas_getch(var* args, usize size, gc* ngc) {
|
||||
return var::num((double)this_window.noecho_getch());
|
||||
}
|
||||
|
||||
var nas_kbhit(var* args, usize size, gc* ngc) {
|
||||
return var::num((double)this_window.noecho_kbhit());
|
||||
}
|
||||
|
||||
var nas_noblock(var* args, usize size, gc* ngc) {
|
||||
if (this_window.noecho_kbhit()) {
|
||||
return var::num((double)this_window.noecho_getch());
|
||||
}
|
||||
return nil;
|
||||
}
|
||||
|
||||
module_func_info func_tbl[]={
|
||||
{"nas_getch",nas_getch},
|
||||
{"nas_kbhit",nas_kbhit},
|
||||
{"nas_noblock",nas_noblock},
|
||||
{nullptr,nullptr}
|
||||
};
|
||||
|
||||
extern "C" module_func_info* get(ghost_register_table* table) {
|
||||
return func_tbl;
|
||||
#include "../nasal.h"
|
||||
#include <iostream>
|
||||
|
||||
#ifndef _MSC_VER
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <conio.h>
|
||||
#else
|
||||
#include <fcntl.h>
|
||||
#include <termios.h>
|
||||
#endif
|
||||
|
||||
class noecho_input {
|
||||
private:
|
||||
#ifndef _WIN32
|
||||
struct termios init_termios;
|
||||
struct termios new_termios;
|
||||
int peek_char=-1;
|
||||
#endif
|
||||
public:
|
||||
noecho_input() {
|
||||
#ifndef _WIN32
|
||||
tcflush(0, TCIOFLUSH);
|
||||
tcgetattr(0, &init_termios);
|
||||
new_termios=init_termios;
|
||||
new_termios.c_lflag&=~(ICANON|ECHO|ECHONL|ECHOE);
|
||||
// vmin=0 is nonblock input, but in wsl there is a bug that will block input
|
||||
// so we use fcntl to write the nonblock input
|
||||
new_termios.c_cc[VMIN]=1;
|
||||
new_termios.c_cc[VTIME]=0;
|
||||
tcsetattr(0, TCSANOW, &new_termios);
|
||||
#endif
|
||||
}
|
||||
~noecho_input() {
|
||||
#ifndef _WIN32
|
||||
tcflush(0, TCIOFLUSH);
|
||||
tcsetattr(0, TCSANOW, &init_termios);
|
||||
#endif
|
||||
}
|
||||
int noecho_kbhit() {
|
||||
#ifndef _WIN32
|
||||
unsigned char ch=0;
|
||||
int nread=0;
|
||||
if (peek_char!=-1) {
|
||||
return 1;
|
||||
}
|
||||
int flag=fcntl(0, F_GETFL);
|
||||
fcntl(0, F_SETFL,flag|O_NONBLOCK);
|
||||
nread=read(0, &ch, 1);
|
||||
fcntl(0, F_SETFL, flag);
|
||||
if (nread==1) {
|
||||
peek_char=ch;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
#else
|
||||
return kbhit();
|
||||
#endif
|
||||
}
|
||||
int noecho_getch() {
|
||||
#ifndef _WIN32
|
||||
int ch=0;
|
||||
if (peek_char!=-1) {
|
||||
ch=peek_char;
|
||||
peek_char=-1;
|
||||
return ch;
|
||||
}
|
||||
ssize_t tmp=read(0, &ch, 1);
|
||||
return ch;
|
||||
#else
|
||||
return getch();
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
noecho_input this_window;
|
||||
|
||||
var nas_getch(var* args, usize size, gc* ngc) {
|
||||
return var::num((double)this_window.noecho_getch());
|
||||
}
|
||||
|
||||
var nas_kbhit(var* args, usize size, gc* ngc) {
|
||||
return var::num((double)this_window.noecho_kbhit());
|
||||
}
|
||||
|
||||
var nas_noblock(var* args, usize size, gc* ngc) {
|
||||
if (this_window.noecho_kbhit()) {
|
||||
return var::num((double)this_window.noecho_getch());
|
||||
}
|
||||
return nil;
|
||||
}
|
||||
|
||||
module_func_info func_tbl[]={
|
||||
{"nas_getch",nas_getch},
|
||||
{"nas_kbhit",nas_kbhit},
|
||||
{"nas_noblock",nas_noblock},
|
||||
{nullptr,nullptr}
|
||||
};
|
||||
|
||||
extern "C" module_func_info* get(ghost_register_table* table) {
|
||||
return func_tbl;
|
||||
}
|
||||
|
|
@ -1,296 +1,296 @@
|
|||
#include "../nasal.h"
|
||||
#include <cmath>
|
||||
|
||||
var nas_vec2(var* args, usize size, gc* ngc) {
|
||||
var res=ngc->alloc(vm_vec);
|
||||
res.vec().elems.push_back(args[0]);
|
||||
res.vec().elems.push_back(args[1]);
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3(var* args, usize size, gc* ngc) {
|
||||
var res=ngc->alloc(vm_vec);
|
||||
res.vec().elems.push_back(args[0]);
|
||||
res.vec().elems.push_back(args[1]);
|
||||
res.vec().elems.push_back(args[2]);
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_add(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=2 || v1.size()!=2)
|
||||
return nil;
|
||||
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[1].num()+v1[1].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_sub(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=2 || v1.size()!=2)
|
||||
return nil;
|
||||
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[1].num()-v1[1].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_mult(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=2 || v1.size()!=2)
|
||||
return nil;
|
||||
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[1].num()*v1[1].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_div(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=2 || v1.size()!=2)
|
||||
return nil;
|
||||
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[1].num()/v1[1].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_neg(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=2)
|
||||
return nil;
|
||||
var res=ngc->alloc(vm_vec);
|
||||
res.vec().elems.push_back(var::num(-v0[0].num()));
|
||||
res.vec().elems.push_back(var::num(-v0[1].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_norm(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=2)
|
||||
return nil;
|
||||
auto x=v0[0].num();
|
||||
auto y=v0[1].num();
|
||||
auto t=std::sqrt(x*x+y*y);
|
||||
var res=ngc->alloc(vm_vec);
|
||||
res.vec().elems.push_back(var::num(x/t));
|
||||
res.vec().elems.push_back(var::num(y/t));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_len(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=2)
|
||||
return nil;
|
||||
auto x=v0[0].num();
|
||||
auto y=v0[1].num();
|
||||
return var::num(std::sqrt(x*x+y*y));
|
||||
}
|
||||
|
||||
var nas_vec2_dot(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=2 || v1.size()!=2)
|
||||
return nil;
|
||||
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) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=3 || v1.size()!=3)
|
||||
return nil;
|
||||
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[1].num()+v1[1].num()));
|
||||
res.vec().elems.push_back(var::num(v0[2].num()+v1[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_sub(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=3 || v1.size()!=3)
|
||||
return nil;
|
||||
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[1].num()-v1[1].num()));
|
||||
res.vec().elems.push_back(var::num(v0[2].num()-v1[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_mult(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=3 || v1.size()!=3)
|
||||
return nil;
|
||||
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[1].num()*v1[1].num()));
|
||||
res.vec().elems.push_back(var::num(v0[2].num()*v1[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_div(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=3 || v1.size()!=3)
|
||||
return nil;
|
||||
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[1].num()/v1[1].num()));
|
||||
res.vec().elems.push_back(var::num(v0[2].num()/v1[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_neg(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
var res=ngc->alloc(vm_vec);
|
||||
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[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_norm(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
auto x=v0[0].num();
|
||||
auto y=v0[1].num();
|
||||
auto z=v0[2].num();
|
||||
auto t=std::sqrt(x*x+y*y+z*z);
|
||||
var res=ngc->alloc(vm_vec);
|
||||
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(z/t));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_len(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
auto x=v0[0].num();
|
||||
auto y=v0[1].num();
|
||||
auto z=v0[2].num();
|
||||
return var::num(std::sqrt(x*x+y*y+z*z));
|
||||
}
|
||||
|
||||
var nas_rotate_x(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
auto angle=args[1].num();
|
||||
var res=ngc->alloc(vm_vec);
|
||||
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::cos(angle)-v0[1].num()*std::sin(angle)));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_rotate_y(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
auto angle=args[1].num();
|
||||
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[1].num()));
|
||||
res.vec().elems.push_back(var::num(v0[0].num()*std::sin(angle)+v0[2].num()*std::cos(angle)));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_rotate_z(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
auto angle=args[1].num();
|
||||
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::sin(angle)+v0[1].num()*std::cos(angle)));
|
||||
res.vec().elems.push_back(var::num(v0[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_dot(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=3 || v1.size()!=3)
|
||||
return nil;
|
||||
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[]={
|
||||
{"nas_vec2",nas_vec2},
|
||||
{"nas_vec2_add",nas_vec2_add},
|
||||
{"nas_vec2_sub",nas_vec2_sub},
|
||||
{"nas_vec2_mult",nas_vec2_mult},
|
||||
{"nas_vec2_div",nas_vec2_div},
|
||||
{"nas_vec2_neg",nas_vec2_neg},
|
||||
{"nas_vec2_norm",nas_vec2_norm},
|
||||
{"nas_vec2_len",nas_vec2_len},
|
||||
{"nas_vec2_dot",nas_vec2_dot},
|
||||
{"nas_vec3",nas_vec3},
|
||||
{"nas_vec3_add",nas_vec3_add},
|
||||
{"nas_vec3_sub",nas_vec3_sub},
|
||||
{"nas_vec3_mult",nas_vec3_mult},
|
||||
{"nas_vec3_div",nas_vec3_div},
|
||||
{"nas_vec3_neg",nas_vec3_neg},
|
||||
{"nas_vec3_norm",nas_vec3_norm},
|
||||
{"nas_vec3_len",nas_vec3_len},
|
||||
{"nas_rotate_x",nas_rotate_x},
|
||||
{"nas_rotate_y",nas_rotate_y},
|
||||
{"nas_rotate_z",nas_rotate_z},
|
||||
{"nas_vec3_dot",nas_vec3_dot},
|
||||
{nullptr,nullptr}
|
||||
};
|
||||
|
||||
extern "C" module_func_info* get(ghost_register_table* table) {
|
||||
return func_tbl;
|
||||
#include "../nasal.h"
|
||||
#include <cmath>
|
||||
|
||||
var nas_vec2(var* args, usize size, gc* ngc) {
|
||||
var res=ngc->alloc(vm_vec);
|
||||
res.vec().elems.push_back(args[0]);
|
||||
res.vec().elems.push_back(args[1]);
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3(var* args, usize size, gc* ngc) {
|
||||
var res=ngc->alloc(vm_vec);
|
||||
res.vec().elems.push_back(args[0]);
|
||||
res.vec().elems.push_back(args[1]);
|
||||
res.vec().elems.push_back(args[2]);
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_add(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=2 || v1.size()!=2)
|
||||
return nil;
|
||||
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[1].num()+v1[1].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_sub(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=2 || v1.size()!=2)
|
||||
return nil;
|
||||
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[1].num()-v1[1].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_mult(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=2 || v1.size()!=2)
|
||||
return nil;
|
||||
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[1].num()*v1[1].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_div(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=2 || v1.size()!=2)
|
||||
return nil;
|
||||
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[1].num()/v1[1].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_neg(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=2)
|
||||
return nil;
|
||||
var res=ngc->alloc(vm_vec);
|
||||
res.vec().elems.push_back(var::num(-v0[0].num()));
|
||||
res.vec().elems.push_back(var::num(-v0[1].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_norm(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=2)
|
||||
return nil;
|
||||
auto x=v0[0].num();
|
||||
auto y=v0[1].num();
|
||||
auto t=std::sqrt(x*x+y*y);
|
||||
var res=ngc->alloc(vm_vec);
|
||||
res.vec().elems.push_back(var::num(x/t));
|
||||
res.vec().elems.push_back(var::num(y/t));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec2_len(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=2)
|
||||
return nil;
|
||||
auto x=v0[0].num();
|
||||
auto y=v0[1].num();
|
||||
return var::num(std::sqrt(x*x+y*y));
|
||||
}
|
||||
|
||||
var nas_vec2_dot(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=2 || v1.size()!=2)
|
||||
return nil;
|
||||
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) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=3 || v1.size()!=3)
|
||||
return nil;
|
||||
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[1].num()+v1[1].num()));
|
||||
res.vec().elems.push_back(var::num(v0[2].num()+v1[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_sub(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=3 || v1.size()!=3)
|
||||
return nil;
|
||||
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[1].num()-v1[1].num()));
|
||||
res.vec().elems.push_back(var::num(v0[2].num()-v1[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_mult(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=3 || v1.size()!=3)
|
||||
return nil;
|
||||
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[1].num()*v1[1].num()));
|
||||
res.vec().elems.push_back(var::num(v0[2].num()*v1[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_div(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=3 || v1.size()!=3)
|
||||
return nil;
|
||||
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[1].num()/v1[1].num()));
|
||||
res.vec().elems.push_back(var::num(v0[2].num()/v1[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_neg(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
var res=ngc->alloc(vm_vec);
|
||||
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[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_norm(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
auto x=v0[0].num();
|
||||
auto y=v0[1].num();
|
||||
auto z=v0[2].num();
|
||||
auto t=std::sqrt(x*x+y*y+z*z);
|
||||
var res=ngc->alloc(vm_vec);
|
||||
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(z/t));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_len(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
auto x=v0[0].num();
|
||||
auto y=v0[1].num();
|
||||
auto z=v0[2].num();
|
||||
return var::num(std::sqrt(x*x+y*y+z*z));
|
||||
}
|
||||
|
||||
var nas_rotate_x(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
auto angle=args[1].num();
|
||||
var res=ngc->alloc(vm_vec);
|
||||
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::cos(angle)-v0[1].num()*std::sin(angle)));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_rotate_y(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
auto angle=args[1].num();
|
||||
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[1].num()));
|
||||
res.vec().elems.push_back(var::num(v0[0].num()*std::sin(angle)+v0[2].num()*std::cos(angle)));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_rotate_z(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
if (v0.size()!=3)
|
||||
return nil;
|
||||
auto angle=args[1].num();
|
||||
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::sin(angle)+v0[1].num()*std::cos(angle)));
|
||||
res.vec().elems.push_back(var::num(v0[2].num()));
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_vec3_dot(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_vec || args[1].type!=vm_vec)
|
||||
return nil;
|
||||
auto& v0=args[0].vec().elems;
|
||||
auto& v1=args[1].vec().elems;
|
||||
if (v0.size()!=3 || v1.size()!=3)
|
||||
return nil;
|
||||
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[]={
|
||||
{"nas_vec2",nas_vec2},
|
||||
{"nas_vec2_add",nas_vec2_add},
|
||||
{"nas_vec2_sub",nas_vec2_sub},
|
||||
{"nas_vec2_mult",nas_vec2_mult},
|
||||
{"nas_vec2_div",nas_vec2_div},
|
||||
{"nas_vec2_neg",nas_vec2_neg},
|
||||
{"nas_vec2_norm",nas_vec2_norm},
|
||||
{"nas_vec2_len",nas_vec2_len},
|
||||
{"nas_vec2_dot",nas_vec2_dot},
|
||||
{"nas_vec3",nas_vec3},
|
||||
{"nas_vec3_add",nas_vec3_add},
|
||||
{"nas_vec3_sub",nas_vec3_sub},
|
||||
{"nas_vec3_mult",nas_vec3_mult},
|
||||
{"nas_vec3_div",nas_vec3_div},
|
||||
{"nas_vec3_neg",nas_vec3_neg},
|
||||
{"nas_vec3_norm",nas_vec3_norm},
|
||||
{"nas_vec3_len",nas_vec3_len},
|
||||
{"nas_rotate_x",nas_rotate_x},
|
||||
{"nas_rotate_y",nas_rotate_y},
|
||||
{"nas_rotate_z",nas_rotate_z},
|
||||
{"nas_vec3_dot",nas_vec3_dot},
|
||||
{nullptr,nullptr}
|
||||
};
|
||||
|
||||
extern "C" module_func_info* get(ghost_register_table* table) {
|
||||
return func_tbl;
|
||||
}
|
||||
|
|
@ -1,211 +1,214 @@
|
|||
#include "../nasal.h"
|
||||
#include <unistd.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <winsock.h>
|
||||
#pragma comment(lib,"ws2_32")
|
||||
|
||||
class WSAmanager{
|
||||
private:
|
||||
WSAData data;
|
||||
public:
|
||||
WSAmanager() {
|
||||
WSAStartup(0x1010, &data);
|
||||
}
|
||||
~WSAmanager() {
|
||||
WSACleanup();
|
||||
}
|
||||
};
|
||||
|
||||
static WSAmanager win;
|
||||
#else
|
||||
#include <netdb.h>
|
||||
#include <sys/socket.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <netinet/in.h>
|
||||
#endif
|
||||
|
||||
var nas_socket(var* args, usize size, gc* ngc) {
|
||||
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());
|
||||
return var::num((double)sd);
|
||||
}
|
||||
|
||||
var nas_closesocket(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("closesocket","\"sd\" should be number");
|
||||
#ifdef _WIN32
|
||||
return var::num((double)closesocket(args[0].num()));
|
||||
#else
|
||||
return var::num((double)close(args[0].num()));
|
||||
#endif
|
||||
}
|
||||
|
||||
var nas_shutdown(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_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");
|
||||
return var::num((double)shutdown(args[0].num(),args[1].num()));
|
||||
}
|
||||
|
||||
var nas_bind(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("bind","\"sd\" muse be a number");
|
||||
if (args[1].type!=vm_str)
|
||||
return nas_err("bind","\"ip\" should be a string including an ip with correct format");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("bind","\"port\" must be a number");
|
||||
sockaddr_in server;
|
||||
memset(&server,0,sizeof(sockaddr_in));
|
||||
server.sin_family=AF_INET;
|
||||
server.sin_addr.s_addr=inet_addr(args[1].str().c_str());
|
||||
server.sin_port=htons(args[2].num());
|
||||
return var::num((double)bind(args[0].num(),(sockaddr*)&server,sizeof(server)));
|
||||
}
|
||||
|
||||
var nas_listen(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_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");
|
||||
return var::num((double)listen(args[0].num(),args[1].num()));
|
||||
}
|
||||
|
||||
var nas_connect(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("connect","\"sd\" must be a number");
|
||||
if (args[1].type!=vm_str)
|
||||
return nas_err("connect","\"hostname\" must be a string");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("connect","\"port\" must be a number");
|
||||
sockaddr_in addr;
|
||||
memset(&addr,0,sizeof(sockaddr_in));
|
||||
addr.sin_family=AF_INET;
|
||||
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);
|
||||
return var::num((double)connect(args[0].num(),(sockaddr*)&addr,sizeof(sockaddr_in)));
|
||||
}
|
||||
|
||||
var nas_accept(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("accept","\"sd\" must be a number");
|
||||
sockaddr_in client;
|
||||
int socklen=sizeof(sockaddr_in);
|
||||
#ifdef _WIN32
|
||||
int client_sd=accept(args[0].num(),(sockaddr*)&client,&socklen);
|
||||
#else
|
||||
int client_sd=accept(args[0].num(),(sockaddr*)&client,(socklen_t*)&socklen);
|
||||
#endif
|
||||
var res=ngc->temp=ngc->alloc(vm_hash);
|
||||
auto& hash=res.hash().elems;
|
||||
hash["sd"]=var::num((double)client_sd);
|
||||
hash["ip"]=ngc->newstr(inet_ntoa(client.sin_addr));
|
||||
ngc->temp=nil;
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_send(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("send","\"sd\" must be a number");
|
||||
if (args[1].type!=vm_str)
|
||||
return nas_err("send","\"buff\" must be a string");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("send","\"flags\" muse be a number");
|
||||
return var::num((double)send(args[0].num(),args[1].str().c_str(),args[1].str().length(),args[2].num()));
|
||||
}
|
||||
|
||||
var nas_sendto(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("sendto","\"sd\" must be a number");
|
||||
if (args[1].type!=vm_str)
|
||||
return nas_err("sendto","\"hostname\" must be a string");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("sendto","\"port\" must be a number");
|
||||
if (args[3].type!=vm_str)
|
||||
return nas_err("sendto","\"buff\" must be a string");
|
||||
if (args[4].type!=vm_num)
|
||||
return nas_err("sendto","\"flags\" must be a number");
|
||||
sockaddr_in addr;
|
||||
memset(&addr,0,sizeof(sockaddr_in));
|
||||
addr.sin_family=AF_INET;
|
||||
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);
|
||||
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)));
|
||||
}
|
||||
|
||||
var nas_recv(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("recv","\"sd\" must be a number");
|
||||
if (args[1].type!=vm_num)
|
||||
return nas_err("recv","\"len\" must be a number");
|
||||
if (args[1].num()<=0 || args[1].num()>16*1024*1024)
|
||||
return nas_err("recv","\"len\" out of range");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("recv","\"flags\" muse be a number");
|
||||
var res=ngc->temp=ngc->alloc(vm_hash);
|
||||
auto& hash=res.hash().elems;
|
||||
char* buf=new char[(int)args[1].num()];
|
||||
auto recvsize=recv(args[0].num(),buf,args[1].num(),args[2].num());
|
||||
hash["size"]=var::num((double)recvsize);
|
||||
buf[recvsize>=0?recvsize:0]=0;
|
||||
hash["str"]=ngc->newstr(buf);
|
||||
delete[] buf;
|
||||
ngc->temp=nil;
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_recvfrom(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("recvfrom","\"sd\" must be a number");
|
||||
if (args[1].type!=vm_num)
|
||||
return nas_err("recvfrom","\"len\" must be a number");
|
||||
if (args[1].num()<=0 || args[1].num()>16*1024*1024)
|
||||
return nas_err("recvfrom","\"len\" out of range");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("recvfrom","\"flags\" muse be a number");
|
||||
sockaddr_in addr;
|
||||
int socklen=sizeof(sockaddr_in);
|
||||
var res=ngc->temp=ngc->alloc(vm_hash);
|
||||
auto& hash=res.hash().elems;
|
||||
char* buf=new char[(int)args[1].num()+1];
|
||||
#ifdef _WIN32
|
||||
auto recvsize=recvfrom(args[0].num(),buf,args[1].num(),args[2].num(),(sockaddr*)&addr,&socklen);
|
||||
#else
|
||||
auto recvsize=recvfrom(args[0].num(),buf,args[1].num(),args[2].num(),(sockaddr*)&addr,(socklen_t*)&socklen);
|
||||
#endif
|
||||
hash["size"]=var::num((double)recvsize);
|
||||
buf[recvsize>=0?recvsize:0]=0;
|
||||
hash["str"]=ngc->newstr(buf);
|
||||
delete[] buf;
|
||||
hash["fromip"]=ngc->newstr(inet_ntoa(addr.sin_addr));
|
||||
ngc->temp=nil;
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_errno(var* args, usize size, gc* ngc) {
|
||||
return ngc->newstr(strerror(errno));
|
||||
}
|
||||
|
||||
module_func_info func_tbl[]={
|
||||
{"nas_socket",nas_socket},
|
||||
{"nas_closesocket",nas_closesocket},
|
||||
{"nas_shutdown",nas_shutdown},
|
||||
{"nas_bind",nas_bind},
|
||||
{"nas_listen",nas_listen},
|
||||
{"nas_connect",nas_connect},
|
||||
{"nas_accept",nas_accept},
|
||||
{"nas_send",nas_send},
|
||||
{"nas_sendto",nas_sendto},
|
||||
{"nas_recv",nas_recv},
|
||||
{"nas_recvfrom",nas_recvfrom},
|
||||
{"nas_errno",nas_errno},
|
||||
{nullptr,nullptr}
|
||||
};
|
||||
|
||||
extern "C" module_func_info* get(ghost_register_table* table) {
|
||||
return func_tbl;
|
||||
#include "../nasal.h"
|
||||
|
||||
#ifndef _MSC_VER
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <winsock.h>
|
||||
#pragma comment(lib,"ws2_32")
|
||||
|
||||
class WSAmanager{
|
||||
private:
|
||||
WSAData data;
|
||||
public:
|
||||
WSAmanager() {
|
||||
WSAStartup(0x1010, &data);
|
||||
}
|
||||
~WSAmanager() {
|
||||
WSACleanup();
|
||||
}
|
||||
};
|
||||
|
||||
static WSAmanager win;
|
||||
#else
|
||||
#include <netdb.h>
|
||||
#include <sys/socket.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <netinet/in.h>
|
||||
#endif
|
||||
|
||||
var nas_socket(var* args, usize size, gc* ngc) {
|
||||
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());
|
||||
return var::num((double)sd);
|
||||
}
|
||||
|
||||
var nas_closesocket(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("closesocket","\"sd\" should be number");
|
||||
#ifdef _WIN32
|
||||
return var::num((double)closesocket(args[0].num()));
|
||||
#else
|
||||
return var::num((double)close(args[0].num()));
|
||||
#endif
|
||||
}
|
||||
|
||||
var nas_shutdown(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_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");
|
||||
return var::num((double)shutdown(args[0].num(),args[1].num()));
|
||||
}
|
||||
|
||||
var nas_bind(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("bind","\"sd\" muse be a number");
|
||||
if (args[1].type!=vm_str)
|
||||
return nas_err("bind","\"ip\" should be a string including an ip with correct format");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("bind","\"port\" must be a number");
|
||||
sockaddr_in server;
|
||||
memset(&server,0,sizeof(sockaddr_in));
|
||||
server.sin_family=AF_INET;
|
||||
server.sin_addr.s_addr=inet_addr(args[1].str().c_str());
|
||||
server.sin_port=htons(args[2].num());
|
||||
return var::num((double)bind(args[0].num(),(sockaddr*)&server,sizeof(server)));
|
||||
}
|
||||
|
||||
var nas_listen(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_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");
|
||||
return var::num((double)listen(args[0].num(),args[1].num()));
|
||||
}
|
||||
|
||||
var nas_connect(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("connect","\"sd\" must be a number");
|
||||
if (args[1].type!=vm_str)
|
||||
return nas_err("connect","\"hostname\" must be a string");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("connect","\"port\" must be a number");
|
||||
sockaddr_in addr;
|
||||
memset(&addr,0,sizeof(sockaddr_in));
|
||||
addr.sin_family=AF_INET;
|
||||
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);
|
||||
return var::num((double)connect(args[0].num(),(sockaddr*)&addr,sizeof(sockaddr_in)));
|
||||
}
|
||||
|
||||
var nas_accept(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("accept","\"sd\" must be a number");
|
||||
sockaddr_in client;
|
||||
int socklen=sizeof(sockaddr_in);
|
||||
#ifdef _WIN32
|
||||
int client_sd=accept(args[0].num(),(sockaddr*)&client,&socklen);
|
||||
#else
|
||||
int client_sd=accept(args[0].num(),(sockaddr*)&client,(socklen_t*)&socklen);
|
||||
#endif
|
||||
var res=ngc->temp=ngc->alloc(vm_hash);
|
||||
auto& hash=res.hash().elems;
|
||||
hash["sd"]=var::num((double)client_sd);
|
||||
hash["ip"]=ngc->newstr(inet_ntoa(client.sin_addr));
|
||||
ngc->temp=nil;
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_send(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("send","\"sd\" must be a number");
|
||||
if (args[1].type!=vm_str)
|
||||
return nas_err("send","\"buff\" must be a string");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("send","\"flags\" muse be a number");
|
||||
return var::num((double)send(args[0].num(),args[1].str().c_str(),args[1].str().length(),args[2].num()));
|
||||
}
|
||||
|
||||
var nas_sendto(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("sendto","\"sd\" must be a number");
|
||||
if (args[1].type!=vm_str)
|
||||
return nas_err("sendto","\"hostname\" must be a string");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("sendto","\"port\" must be a number");
|
||||
if (args[3].type!=vm_str)
|
||||
return nas_err("sendto","\"buff\" must be a string");
|
||||
if (args[4].type!=vm_num)
|
||||
return nas_err("sendto","\"flags\" must be a number");
|
||||
sockaddr_in addr;
|
||||
memset(&addr,0,sizeof(sockaddr_in));
|
||||
addr.sin_family=AF_INET;
|
||||
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);
|
||||
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)));
|
||||
}
|
||||
|
||||
var nas_recv(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("recv","\"sd\" must be a number");
|
||||
if (args[1].type!=vm_num)
|
||||
return nas_err("recv","\"len\" must be a number");
|
||||
if (args[1].num()<=0 || args[1].num()>16*1024*1024)
|
||||
return nas_err("recv","\"len\" out of range");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("recv","\"flags\" muse be a number");
|
||||
var res=ngc->temp=ngc->alloc(vm_hash);
|
||||
auto& hash=res.hash().elems;
|
||||
char* buf=new char[(int)args[1].num()];
|
||||
auto recvsize=recv(args[0].num(),buf,args[1].num(),args[2].num());
|
||||
hash["size"]=var::num((double)recvsize);
|
||||
buf[recvsize>=0?recvsize:0]=0;
|
||||
hash["str"]=ngc->newstr(buf);
|
||||
delete[] buf;
|
||||
ngc->temp=nil;
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_recvfrom(var* args, usize size, gc* ngc) {
|
||||
if (args[0].type!=vm_num)
|
||||
return nas_err("recvfrom","\"sd\" must be a number");
|
||||
if (args[1].type!=vm_num)
|
||||
return nas_err("recvfrom","\"len\" must be a number");
|
||||
if (args[1].num()<=0 || args[1].num()>16*1024*1024)
|
||||
return nas_err("recvfrom","\"len\" out of range");
|
||||
if (args[2].type!=vm_num)
|
||||
return nas_err("recvfrom","\"flags\" muse be a number");
|
||||
sockaddr_in addr;
|
||||
int socklen=sizeof(sockaddr_in);
|
||||
var res=ngc->temp=ngc->alloc(vm_hash);
|
||||
auto& hash=res.hash().elems;
|
||||
char* buf=new char[(int)args[1].num()+1];
|
||||
#ifdef _WIN32
|
||||
auto recvsize=recvfrom(args[0].num(),buf,args[1].num(),args[2].num(),(sockaddr*)&addr,&socklen);
|
||||
#else
|
||||
auto recvsize=recvfrom(args[0].num(),buf,args[1].num(),args[2].num(),(sockaddr*)&addr,(socklen_t*)&socklen);
|
||||
#endif
|
||||
hash["size"]=var::num((double)recvsize);
|
||||
buf[recvsize>=0?recvsize:0]=0;
|
||||
hash["str"]=ngc->newstr(buf);
|
||||
delete[] buf;
|
||||
hash["fromip"]=ngc->newstr(inet_ntoa(addr.sin_addr));
|
||||
ngc->temp=nil;
|
||||
return res;
|
||||
}
|
||||
|
||||
var nas_errno(var* args, usize size, gc* ngc) {
|
||||
return ngc->newstr(strerror(errno));
|
||||
}
|
||||
|
||||
module_func_info func_tbl[]={
|
||||
{"nas_socket",nas_socket},
|
||||
{"nas_closesocket",nas_closesocket},
|
||||
{"nas_shutdown",nas_shutdown},
|
||||
{"nas_bind",nas_bind},
|
||||
{"nas_listen",nas_listen},
|
||||
{"nas_connect",nas_connect},
|
||||
{"nas_accept",nas_accept},
|
||||
{"nas_send",nas_send},
|
||||
{"nas_sendto",nas_sendto},
|
||||
{"nas_recv",nas_recv},
|
||||
{"nas_recvfrom",nas_recvfrom},
|
||||
{"nas_errno",nas_errno},
|
||||
{nullptr,nullptr}
|
||||
};
|
||||
|
||||
extern "C" module_func_info* get(ghost_register_table* table) {
|
||||
return func_tbl;
|
||||
}
|
||||
Loading…
Reference in New Issue