static value socket_set_blocking( value o, value b ) {
SOCKET sock = val_sock(o);
val_check(b,bool);
gc_enter_blocking();
#ifdef NEKO_WINDOWS
{
unsigned long arg = val_bool(b)?0:1;
if( ioctlsocket(sock,FIONBIO,&arg) != 0 )
{
gc_exit_blocking();
return alloc_null();
}
}
#else
{
int rights = fcntl(sock,F_GETFL);
if( rights == -1 )
{
gc_exit_blocking();
return alloc_null();
}
if( val_bool(b) )
rights &= ~O_NONBLOCK;
else
rights |= O_NONBLOCK;
if( fcntl(sock,F_SETFL,rights) == -1 )
{
gc_exit_blocking();
return alloc_null();
}
}
#endif
gc_exit_blocking();
return alloc_bool(true);
}
/**
sys_getch : bool -> int
<doc>Read a character from stdin with or without echo</doc>
**/
static value sys_getch( value b ) {
#if defined(HX_WINRT) || defined(EMSCRIPTEN) || defined(EPPC)
return alloc_null();
#elif defined(NEKO_WINDOWS)
val_check(b,bool);
gc_enter_blocking();
int result = val_bool(b)?getche():getch();
gc_exit_blocking();
return alloc_int( result );
#else
// took some time to figure out how to do that
// without relying on ncurses, which clear the
// terminal on initscr()
int c;
struct termios term, old;
val_check(b,bool);
gc_enter_blocking();
tcgetattr(fileno(stdin), &old);
term = old;
cfmakeraw(&term);
tcsetattr(fileno(stdin), 0, &term);
c = getchar();
tcsetattr(fileno(stdin), 0, &old);
if( val_bool(b) ) fputc(c,stdout);
gc_exit_blocking();
return alloc_int(c);
# endif
}
value flush(value a,value b,value c){
int fd = val_int(a);
bool flushIn = val_bool(b);
bool flushOut = val_bool(c);
int flushType;
//---------------------------------------------
#if defined( TARGET_OSX ) || defined( TARGET_LINUX )
if( flushIn && flushOut) flushType = TCIOFLUSH;
else if(flushIn) flushType = TCIFLUSH;
else if(flushOut) flushType = TCOFLUSH;
else return alloc_null();
tcflush(fd, flushType);
#endif
//---------------------------------------------
//---------------------------------------------
#ifdef TARGET_WIN32
if( flushIn && flushOut) flushType = PURGE_TXCLEAR | PURGE_RXCLEAR;
else if(flushIn) flushType = PURGE_RXCLEAR;
else if(flushOut) flushType = PURGE_TXCLEAR;
else return alloc_null();
PurgeComm((HANDLE)fd, flushType);
#endif
//---------------------------------------------
return alloc_null();
}
EXTERN int val_compare( value a, value b ) {
char tmp_buf[32];
switch( C(val_type(a),val_type(b)) ) {
case C(VAL_INT,VAL_INT):
return icmp(val_int(a),val_int(b));
case C(VAL_INT32,VAL_INT):
return icmp(val_int32(a),val_int(b));
case C(VAL_INT,VAL_INT32):
return icmp(val_int(a),val_int32(b));
case C(VAL_INT32,VAL_INT32):
return icmp(val_int32(a),val_int32(b));
case C(VAL_INT,VAL_FLOAT):
return fcmp(val_int(a),val_float(b));
case C(VAL_INT32,VAL_FLOAT):
return fcmp(val_int32(a),val_float(b));
case C(VAL_INT,VAL_STRING):
return scmp(tmp_buf,sprintf(tmp_buf,"%d",val_int(a)),val_string(b),val_strlen(b));
case C(VAL_INT32,VAL_STRING):
return scmp(tmp_buf,sprintf(tmp_buf,"%d",val_int32(a)),val_string(b),val_strlen(b));
case C(VAL_FLOAT,VAL_INT):
return fcmp(val_float(a),val_int(b));
case C(VAL_FLOAT,VAL_INT32):
return fcmp(val_float(a),val_int32(b));
case C(VAL_FLOAT,VAL_FLOAT):
return fcmp(val_float(a),val_float(b));
case C(VAL_FLOAT,VAL_STRING):
return scmp(tmp_buf,sprintf(tmp_buf,FLOAT_FMT,val_float(a)),val_string(b),val_strlen(b));
case C(VAL_STRING,VAL_INT):
return scmp(val_string(a),val_strlen(a),tmp_buf,sprintf(tmp_buf,"%d",val_int(b)));
case C(VAL_STRING,VAL_INT32):
return scmp(val_string(a),val_strlen(a),tmp_buf,sprintf(tmp_buf,"%d",val_int32(b)));
case C(VAL_STRING,VAL_FLOAT):
return scmp(val_string(a),val_strlen(a),tmp_buf,sprintf(tmp_buf,FLOAT_FMT,val_float(b)));
case C(VAL_STRING,VAL_BOOL):
return scmp(val_string(a),val_strlen(a),val_bool(b)?"true":"false",val_bool(b)?4:5);
case C(VAL_BOOL,VAL_STRING):
return scmp(val_bool(a)?"true":"false",val_bool(a)?4:5,val_string(b),val_strlen(b));
case C(VAL_STRING,VAL_STRING):
return scmp(val_string(a),val_strlen(a),val_string(b),val_strlen(b));
case C(VAL_BOOL,VAL_BOOL):
return (a == b) ? 0 : (val_bool(a) ? 1 : -1);
case C(VAL_OBJECT,VAL_OBJECT):
if( a == b )
return 0;
{
value tmp = val_field(a,id_compare);
if( tmp == val_null )
return invalid_comparison;
a = val_callEx(a,tmp,&b,1,NULL);
}
if( val_is_int(a) )
return val_int(a);
return invalid_comparison;
default:
if( a == b )
return 0;
return invalid_comparison;
}
}
/**
socket_shutdown : 'socket -> read:bool -> write:bool -> void
<doc>Prevent the socket from further reading or writing or both.</doc>
**/
static value socket_shutdown( value o, value r, value w ) {
val_check_kind(o,k_socket);
val_check(r,bool);
val_check(w,bool);
if( !val_bool(r) && !val_bool(w) )
return val_true;
if( shutdown(val_sock(o),val_bool(r)?(val_bool(w)?SHUT_RDWR:SHUT_RD):SHUT_WR) )
neko_error();
return val_true;
}
static value os_dialog( value title, value msg, value error, value confirm ) {
int r;
val_check(title,string);
val_check(msg,string);
val_check(error,bool);
val_check(confirm,bool);
r = sys_dialog(
val_string(title),
val_string(msg),
(val_bool(error)?DLG_ERROR:0) | (val_bool(confirm)?DLG_CONFIRM:0)
);
return alloc_bool(r);
}
/**
socket_shutdown : 'socket -> read:bool -> write:bool -> void
<doc>Prevent the socket from further reading or writing or both.</doc>
**/
static value socket_shutdown( value o, value r, value w ) {
SOCKET sock = val_sock(o);
val_check(r,bool);
val_check(w,bool);
if( !val_bool(r) && !val_bool(w) )
return alloc_bool(true);
gc_enter_blocking();
if( shutdown(sock,val_bool(r)?(val_bool(w)?SHUT_RDWR:SHUT_RD):SHUT_WR) )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
return alloc_bool(true);
}
/**
enable_jit : ?bool -> ?bool
<doc>Enable or disable the JIT. Calling enable_jit(null) tells if JIT is enabled or not</doc>
**/
static value enable_jit( value b ) {
if( val_is_null(b) )
return alloc_bool(neko_vm_jit(neko_vm_current(),-1));
val_check(b,bool);
neko_vm_jit(neko_vm_current(),val_bool(b));
return val_null;
}
static value dialogs_message_box( value title, value msg, value error ) {
val_check(title,string);
val_check(msg,string);
val_check(error,bool);
systools_dialogs_message_box(val_string(title),val_string(msg),val_bool(error));
return val_null;
}
//Be very careful with this, it does not support offsets into buffers yet
value vertexAttribPointer( value *args, int count )
{
enum {index,size,type,normalized,stride,pointer};
if (count != 6)
{
throw "vertexAttribPointer invalid parameter length";
}
char *ptr = NULL;
if (val_is_buffer (args[pointer]))
{
std::cout << "vertexAttribPointer does not accept data for pointer arg" << std::endl;
//ptr = buffer_data( val_to_buffer ( args[pointer] ) );
}
else if (val_is_int (args[pointer]))
{
ptr = ((char *)NULL + val_int(args[pointer]));
}
glVertexAttribPointer(
(GLuint)val_int( args[index] ),
(GLint)val_int( args[size] ),
(GLenum)val_int( args[type] ),
(GLboolean)val_bool( args[normalized] ),
(GLsizei)val_int( args[stride] ),
(const GLvoid *)ptr );
return alloc_null( );
}
static value os_winlog_set_button( value wnd, value txt, value enabled ) {
val_check_kind(wnd,k_winlog);
val_check(txt,string);
val_check(enabled,bool);
sys_winlog_set_button(val_window(wnd)->p,val_string(txt),val_bool(enabled));
return val_null;
}
static value key_from_pem(value data, value pub, value pass){
mbedtls_pk_context *pk;
int r, len;
value v;
unsigned char *buf;
val_check(data, string);
val_check(pub, bool);
if (!val_is_null(pass)) val_check(pass, string);
len = val_strlen(data)+1;
buf = (unsigned char *)alloc(len);
memcpy(buf, val_string(data), len-1);
buf[len-1] = '\0';
pk = (mbedtls_pk_context *)alloc(sizeof(mbedtls_pk_context));
mbedtls_pk_init(pk);
if( val_bool(pub) )
r = mbedtls_pk_parse_public_key( pk, buf, len );
else if( val_is_null(pass) )
r = mbedtls_pk_parse_key( pk, buf, len, NULL, 0 );
else
r = mbedtls_pk_parse_key( pk, buf, len, (const unsigned char*)val_string(pass), val_strlen(pass) );
if( r != 0 ){
mbedtls_pk_free(pk);
return ssl_error(r);
}
v = alloc_abstract(k_pkey,pk);
val_gc(v,free_pkey);
return v;
}
value snow_system_lock_cursor(value _enable) {
snow::window::system_lock_cursor( val_bool(_enable) );
return alloc_null();
} DEFINE_PRIM(snow_system_lock_cursor, 1);
value snow_system_enable_vsync( value _enable ) {
int result = snow::window::system_enable_vsync( val_bool(_enable) );
return alloc_int( result );
} DEFINE_PRIM(snow_system_enable_vsync, 1);
/**
udpr_send_char : peer -> data:int -> chan:int -> reliable:bool -> void
Send a character [ over a connected socket. Must be in the range 0..255</doc>
**/
static value udpr_send_char( value p, value data, value chan, value reliable ) {
ENetPeer *peer;
ENetPacket *packet;
int c,d;
char buf[2];
val_check_kind(p,k_udprpeer);
val_check(data,int);
val_check(chan,int);
val_check(reliable,bool);
peer = (ENetPeer *)val_data(p);
c = val_int(chan);
d = val_int(data);
if( peer == NULL || c < 0 || c > 255 || d < 0 || d > 255 )
neko_error();
buf[0] = (unsigned char)d;
buf[1] = '\0';
packet = enet_packet_create(
buf,
1,
val_bool(reliable) ? ENET_PACKET_FLAG_RELIABLE : 0);
if(enet_peer_send(peer, c, packet))
neko_error();
return val_true;
}
value lime_window_set_enable_text_events (value window, value enabled) {
Window* targetWindow = (Window*)(intptr_t)val_float (window);
targetWindow->SetEnableTextEvents (val_bool (enabled));
return alloc_null ();
}
/**
udpr_write : ENetPeer-> data:string -> Channel->Reliable:Bool->void
Send a full string [data]
**/
static value udpr_write(value p, value data, value chan, value reliable)
{
ENetPeer *peer;
ENetPacket *packet;
int c;
val_check_kind(p,k_udprpeer);
val_check(data,string);
val_check(chan,int);
val_check(reliable,bool);
c = val_int(chan);
peer = (ENetPeer *)val_data(p);
#ifdef ENET_DEBUG_FULL
fprintf(stderr, "udpr_write: Writing packet '%s' to peer %x on channel %d\n", val_string(data), peer, c);
fprintf(stderr, "peer state: %d peer channels: %d\n", peer -> state, peer->channelCount);
#endif
if(peer == NULL || c < 0 || c > 255)
neko_error();
packet = enet_packet_create(
val_string(data),
val_strlen(data),
val_bool(reliable) ? ENET_PACKET_FLAG_RELIABLE : 0);
if(enet_peer_send(peer, c, packet)) {
#ifdef ENET_DEBUG
fprintf(stderr, "ERROR: udpr_write: enet_peer_send error\n");
fprintf(stderr, "peer state: %d peer channels: %d\n", peer -> state, peer->channelCount);
#endif
neko_error();
}
return val_true;
}
/**
udpr_send : peer -> data:string -> pos:int -> len:int -> chan:int -> reliable:bool -> int
Send up to [len] bytes from [buf] starting at [pos] over a connected socket on channel [chan]
using reliable setting [reliable]
Return the number of bytes sent.
**/
static value udpr_send( value p, value data, value pos, value len, value chan, value reliable ) {
ENetPeer *peer;
ENetPacket *packet;
int pp,l,sLen,c;
val_check_kind(p,k_udprpeer);
val_check(data,string);
val_check(pos,int);
val_check(len,int);
val_check(chan,int);
val_check(reliable,bool);
peer = (ENetPeer *)val_data(p);
pp = val_int(pos);
l = val_int(len);
sLen = val_strlen(data);
c = val_int(chan);
if( peer == NULL || c < 0 || c > 255 || pp < 0 || l < 0 || pp > sLen || pp + l > sLen )
neko_error();
packet = enet_packet_create(
val_string(data) + pp,
l,
val_bool(reliable) ? ENET_PACKET_FLAG_RELIABLE : 0);
if(enet_peer_send(peer, c, packet))
neko_error();
return alloc_int(l);
}
value socket_set_fast_send( value o, value b )
{
SOCKET sock = val_sock(o);
val_check(b,bool);
int fast = val_bool(b);
setsockopt(sock,IPPROTO_TCP,TCP_NODELAY,(char*)&fast,sizeof(fast));
return alloc_null();
}
static value dialogs_dialog_box( value title, value msg, value error ) {
int r;
val_check(title,string);
val_check(msg,string);
val_check(error,bool);
r = systools_dialogs_dialog_box(val_string(title),val_string(msg),val_bool(error));
return alloc_bool(r);
}
/**
run_gc : major:bool -> void
<doc>Run the Neko garbage collector</doc>
**/
static value run_gc( value b ) {
val_check(b,bool);
if( val_bool(b) )
neko_gc_major();
else
neko_gc_loop();
return val_null;
}
/**
thread_read_message : block:bool -> any
<doc>
Reads a message from the message queue. If [block] is true, the
function only returns when a message is available. If [block] is
false and no message is available in the queue, the function will
return immediatly [null].
</doc>
**/
static value thread_read_message( value block ) {
value v = thread_current();
vthread *t;
if( v == NULL )
neko_error();
t = val_thread(v);
val_check(block,bool);
return _deque_pop( &t->q, val_bool(block) );
}
value wx_timer_start(value inTimer, value inMilliSeconds, value inOneShot)
{
wxTimer *timer;
if (ValueToWX(inTimer,timer))
{
timer->Start(val_int(inMilliSeconds), val_bool(inOneShot) );
}
return alloc_null();
}
/**
socket_set_fast_send : 'socket -> bool -> void
<doc>
Disable or enable to TCP_NODELAY flag for the socket
</doc>
**/
static value socket_set_fast_send( value s, value f ) {
int fast;
val_check_kind(s,k_socket);
val_check(f,bool);
fast = val_bool(f);
if( setsockopt(val_sock(s),IPPROTO_TCP,TCP_NODELAY,(char*)&fast,sizeof(fast)) )
neko_error();
return val_null;
}
double api_val_field_numeric(value arg1,int arg2)
{
value field = val_field(arg1, arg2);
if (val_is_number(field))
return val_number(field);
if (val_is_bool(field))
return val_bool(field);
return 0;
}
value wx_dc_draw_bitmap(value inDC, value inBitmap, value x, value y, value transparent)
{
wxDC *dc;
wxBitmap *bitmap;
if (ValueToWX(inDC,dc) && ValueToWX(inBitmap,bitmap) )
{
dc->DrawBitmap(*bitmap, val_int(x), val_int(y), val_bool(transparent) );
}
return alloc_null();
}
value lime_image_data_util_copy_pixels (value image, value sourceImage, value sourceRect, value destPoint, value mergeAlpha) {
Image _image = Image (image);
Image _sourceImage = Image (sourceImage);
Rectangle _sourceRect = Rectangle (sourceRect);
Vector2 _destPoint = Vector2 (destPoint);
ImageDataUtil::CopyPixels (&_image, &_sourceImage, &_sourceRect, &_destPoint, val_bool (mergeAlpha));
return alloc_null ();
}
value snow_window_bordered(value _window, value _enable) {
snow::window::Window* window = snow::from_hx<snow::window::Window>(_window);
if( window ) {
window->bordered( val_bool(_enable) );
}
return alloc_null();
} DEFINE_PRIM(snow_window_bordered, 2);
value snow_window_fullscreen( value _window, value _enable, value _flag ) {
snow::window::Window* window = snow::from_hx<snow::window::Window>(_window);
if( window ) {
window->fullscreen( val_bool(_enable), val_int(_flag) );
}
return alloc_null();
} DEFINE_PRIM(snow_window_fullscreen, 3);
static value conf_set_verify( value config, value b ) {
val_check_kind(config, k_ssl_conf);
if( !val_is_null(b) ) val_check(b, bool);
if( val_is_null(b) )
mbedtls_ssl_conf_authmode(val_conf(config), MBEDTLS_SSL_VERIFY_OPTIONAL);
else if( val_bool(b) )
mbedtls_ssl_conf_authmode(val_conf(config), MBEDTLS_SSL_VERIFY_REQUIRED);
else
mbedtls_ssl_conf_authmode(val_conf(config), MBEDTLS_SSL_VERIFY_NONE);
return val_true;
}
