static value socket_recv_from( value o, value dataBuf, value pos, value len, value addr ) {
int p,l,ret;
int retry = 0;
struct sockaddr_in saddr;
SockLen slen = sizeof(saddr);
val_check_kind(o,k_socket);
val_check(dataBuf,buffer);
buffer buf = val_to_buffer(dataBuf);
char *data = buffer_data(buf);
int dlen = buffer_size(buf);
val_check(pos,int);
val_check(len,int);
val_check(addr,object);
p = val_int(pos);
l = val_int(len);
if( p < 0 || l < 0 || p > dlen || p + l > dlen )
neko_error();
SOCKET sock = val_sock(o);
gc_enter_blocking();
POSIX_LABEL(recv_from_again);
if( retry++ > NRETRYS ) {
ret = recv(sock,data+p,l,MSG_NOSIGNAL);
} else
ret = recvfrom(sock, data + p , l, MSG_NOSIGNAL, (struct sockaddr*)&saddr, &slen);
if( ret == SOCKET_ERROR ) {
HANDLE_EINTR(recv_from_again);
return block_error();
}
gc_exit_blocking();
alloc_field(addr,f_host,alloc_int32(*(int*)&saddr.sin_addr));
alloc_field(addr,f_port,alloc_int(ntohs(saddr.sin_port)));
return alloc_int(ret);
}
/**
host_resolve : string -> 'int32
<doc>Resolve the given host string into an IP address.</doc>
**/
static value host_resolve( value host ) {
unsigned int ip;
val_check(host,string);
const char *hostName = val_string(host);
gc_enter_blocking();
ip = inet_addr(hostName);
if( ip == INADDR_NONE ) {
struct hostent *h;
# if defined(NEKO_WINDOWS) || defined(NEKO_MAC) || defined(BLACKBERRY)
h = gethostbyname(hostName);
# else
struct hostent hbase;
char buf[1024];
int errcode;
gethostbyname_r(hostName,&hbase,buf,1024,&h,&errcode);
# endif
if( h == NULL ) {
gc_exit_blocking();
return alloc_null();
}
ip = *((unsigned int*)h->h_addr);
}
gc_exit_blocking();
return alloc_int32(ip);
}
/**
update_crc32 : crc:'int32 -> string -> pos:int -> len:int -> 'int32
<doc>Update a CRC32 value with a substring</doc>
**/
static value update_crc32( value crc, value s, value pos, value len ) {
val_check(crc,int);
val_check(s,string);
val_check(pos,int);
val_check(len,int);
if( val_int(pos) < 0 || val_int(len) < 0 || val_int(pos) + val_int(len) > val_strlen(s) )
return alloc_null();
return alloc_int32(crc32(val_int(crc),(Bytef*)(val_string(s)+val_int(pos)),val_int(len)));
}
static value udpr_peer_address( value p ) {
val_check_kind(p,k_udprpeer);
ENetPeer* peer = (ENetPeer *)val_data(p);
if(peer == NULL)
neko_error();
value rv = alloc_array(2);
val_array_ptr(rv)[0] = alloc_int32(peer->address.host);
val_array_ptr(rv)[1] = alloc_int(peer->address.port);
return rv;
}
/**
math_abs : number -> number
<doc>Return absolute value of a number</doc>
**/
static value math_abs( value n ) {
switch( val_type(n) ) {
case VAL_INT:
return alloc_int( abs(val_int(n)) );
case VAL_INT32:
return alloc_int32( abs(val_int32(n)) );
case VAL_FLOAT:
return alloc_float( fabs(val_float(n)) );
default:
neko_error();
}
}
static value udpr_host_address( value h ) {
val_check_kind(h,k_udprhost);
ENetHost* host = (ENetHost *)val_data(h);
if(host == NULL)
neko_error();
value rv = alloc_array(2);
if(host->address.host != 0) {
val_array_ptr(rv)[0] = alloc_int32(host->address.host);
val_array_ptr(rv)[1] = alloc_int(host->address.port);
}
else {
struct sockaddr_in addr;
unsigned int addrlen = sizeof(addr);
if( getsockname(host->socket,(struct sockaddr*)&addr,&addrlen) == SOCKET_ERROR )
neko_error();
val_array_ptr(rv)[0] = alloc_int32(*(int*)&addr.sin_addr);
val_array_ptr(rv)[1] = alloc_int(ntohs(addr.sin_port));
}
return rv;
}
/**
socket_host : 'socket -> #address
<doc>Return the socket local address composed of an (host,port) array</doc>
**/
static value socket_host( value o ) {
struct sockaddr_in addr;
unsigned int addrlen = sizeof(addr);
value ret;
val_check_kind(o,k_socket);
if( getsockname(val_sock(o),(struct sockaddr*)&addr,&addrlen) == SOCKET_ERROR )
neko_error();
ret = alloc_array(2);
val_array_ptr(ret)[0] = alloc_int32(*(int*)&addr.sin_addr);
val_array_ptr(ret)[1] = alloc_int(ntohs(addr.sin_port));
return ret;
}
/**
socket_host : 'socket -> #address
<doc>Return the socket local address composed of an (host,port) array</doc>
**/
static value socket_host( value o ) {
SOCKET sock = val_sock(o);
struct sockaddr_in addr;
SockLen addrlen = sizeof(addr);
value ret;
if( getsockname(sock,(struct sockaddr*)&addr,&addrlen) == SOCKET_ERROR )
return alloc_null();
ret = alloc_array(2);
val_array_set_i(ret,0,alloc_int32(*(int*)&addr.sin_addr));
val_array_set_i(ret,1,alloc_int(ntohs(addr.sin_port)));
return ret;
}
/**
host_resolve : string -> 'int32
<doc>Resolve the given host string into an IP address.</doc>
**/
static value host_resolve( value host ) {
unsigned int ip;
val_check(host,string);
ip = inet_addr(val_string(host));
if( ip == INADDR_NONE ) {
struct hostent *h;
# if defined(NEKO_WINDOWS) || defined(NEKO_MAC)
h = gethostbyname(val_string(host));
# else
struct hostent hbase;
char buf[2048];
int errcode;
gethostbyname_r(val_string(host),&hbase,buf,2048,&h,&errcode);
# endif
if( h == NULL )
neko_error();
ip = *((unsigned int*)h->h_addr);
}
return alloc_int32(ip);
}
/**
socket_recv_from : 'socket -> buf:string -> pos:int -> length:int -> addr:{host:'int32,port:int} -> int
<doc>
Read data from an unconnected UDP socket, store the address from which we received data in addr.
</doc>
**/
static value socket_recv_from( value o, value data, value pos, value len, value addr ) {
int p,l,dlen,ret;
int retry = 0;
struct sockaddr_in saddr;
int slen = sizeof(saddr);
val_check_kind(o,k_socket);
val_check(data,string);
val_check(pos,int);
val_check(len,int);
val_check(addr,object);
p = val_int(pos);
l = val_int(len);
dlen = val_strlen(data);
if( p < 0 || l < 0 || p > dlen || p + l > dlen )
neko_error();
POSIX_LABEL(recv_from_again);
if( retry++ > NRETRYS ) {
sock_tmp t;
t.sock = val_sock(o);
t.buf = val_string(data) + p;
t.size = l;
neko_thread_blocking(tmp_recv,&t);
ret = t.ret;
} else
ret = recvfrom(val_sock(o), val_string(data) + p , l, MSG_NOSIGNAL, (struct sockaddr*)&saddr, &slen);
if( ret == SOCKET_ERROR ) {
HANDLE_EINTR(recv_from_again);
#ifdef NEKO_WINDOWS
if( WSAGetLastError() == WSAECONNRESET )
ret = 0;
else
#endif
return block_error();
}
alloc_field(addr,f_host,alloc_int32(*(int*)&saddr.sin_addr));
alloc_field(addr,f_port,alloc_int(ntohs(saddr.sin_port)));
return alloc_int(ret);
}
value _ofxOscMessage_getArgAsInt(value a,value b) {
ofxOscMessage* oscMessage = (ofxOscMessage*) val_data(a);
return alloc_int32(oscMessage->getArgAsInt32(val_int(b)));
}
/**
result_next : 'result -> object?
<doc>
Return the next row if available. A row is represented
as an object, which fields have been converted to the
corresponding Neko value (int, float or string). For
Date and DateTime you can specify your own conversion
function using [result_set_conv_date]. By default they're
returned as plain strings. Additionally, the TINYINT(1) will
be converted to either true or false if equal to 0.
</doc>
**/
static value result_next( value o ) {
result *r;
unsigned long *lengths = NULL;
MYSQL_ROW row;
val_check_kind(o,k_result);
r = RESULT(o);
row = mysql_fetch_row(r->r);
if( row == NULL )
return val_null;
{
int i;
value cur = alloc_object(NULL);
r->current = row;
for(i=0;i<r->nfields;i++)
if( row[i] != NULL ) {
value v;
switch( r->fields_convs[i] ) {
case CONV_INT:
v = alloc_best_int(atoi(row[i]));
break;
case CONV_STRING:
v = alloc_string(row[i]);
if( r->conv_string != NULL )
v = val_call1(r->conv_string,v);
break;
case CONV_BOOL:
v = alloc_bool( *row[i] != '0' );
break;
case CONV_FLOAT:
v = alloc_float(atof(row[i]));
break;
case CONV_BINARY:
if( lengths == NULL ) {
lengths = mysql_fetch_lengths(r->r);
if( lengths == NULL )
val_throw(alloc_string("mysql_fetch_lengths"));
}
v = copy_string(row[i],lengths[i]);
if( r->conv_bytes != NULL )
v = val_call1(r->conv_bytes,v);
break;
case CONV_DATE:
if( r->conv_date == NULL )
v = alloc_string(row[i]);
else {
struct tm t;
sscanf(row[i],"%4d-%2d-%2d",&t.tm_year,&t.tm_mon,&t.tm_mday);
t.tm_hour = 0;
t.tm_min = 0;
t.tm_sec = 0;
t.tm_isdst = -1;
t.tm_year -= 1900;
t.tm_mon--;
v = val_call1(r->conv_date,alloc_int32((int)mktime(&t)));
}
break;
case CONV_DATETIME:
if( r->conv_date == NULL )
v = alloc_string(row[i]);
else {
struct tm t;
sscanf(row[i],"%4d-%2d-%2d %2d:%2d:%2d",&t.tm_year,&t.tm_mon,&t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
t.tm_isdst = -1;
t.tm_year -= 1900;
t.tm_mon--;
v = val_call1(r->conv_date,alloc_int32((int)mktime(&t)));
}
break;
default:
v = val_null;
break;
}
alloc_field(cur,r->fields_ids[i],v);
}
return cur;
}
}
/**
get_adler32 : 'stream -> 'int32
<doc>Returns the adler32 value of the stream</doc>
**/
static value get_adler32( value s ) {
if( !val_is_kind(s,k_stream_inf) )
val_check_kind(s,k_stream_def);
return alloc_int32(val_stream(s)->adler);
}
/**
sys_stat : string -> {
gid => int,
uid => int,
atime => 'int32,
mtime => 'int32,
ctime => 'int32,
dev => int,
ino => int,
nlink => int,
rdev => int,
mode => int,
size => int
}
<doc>Run the [stat] command on the given file or directory.</doc>
**/
static value sys_stat( value path ) {
#if defined(EPPC) || defined(KORE_CONSOLE)
return alloc_null();
#else
value o;
val_check(path,string);
#if defined(NEKO_WINDOWS) && !defined(KORE_WINDOWSAPP) && !defined(KORE_XBOX_ONE)
const wchar_t* _path = val_wstring(path);
gc_enter_blocking();
WIN32_FILE_ATTRIBUTE_DATA data;
if( !GetFileAttributesExW(_path,GetFileExInfoStandard,&data) )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
wchar_t fullPath[MAX_PATH+1];
GetFullPathNameW(_path,MAX_PATH+1,fullPath,NULL);
int dev = PathGetDriveNumberW(fullPath);
#define EPOCH_DIFF (134774*24*60*60.0)
ULARGE_INTEGER ui;
o = alloc_empty_object( );
alloc_field(o,val_id("gid"),alloc_int(0));
alloc_field(o,val_id("uid"),alloc_int(0));
ui.LowPart = data.ftLastAccessTime.dwLowDateTime;
ui.HighPart = data.ftLastAccessTime.dwHighDateTime;
alloc_field(o,val_id("atime"),alloc_int32((int)(((double)ui.QuadPart) / 10000000.0 - EPOCH_DIFF)));
ui.LowPart = data.ftLastWriteTime.dwLowDateTime;
ui.HighPart = data.ftLastWriteTime.dwHighDateTime;
alloc_field(o,val_id("mtime"),alloc_int32((int)(((double)ui.QuadPart) / 10000000.0 - EPOCH_DIFF)));
ui.LowPart = data.ftCreationTime.dwLowDateTime;
ui.HighPart = data.ftCreationTime.dwHighDateTime;
alloc_field(o,val_id("ctime"),alloc_int32((int)(((double)ui.QuadPart) / 10000000.0 - EPOCH_DIFF)));
alloc_field(o,val_id("dev"),alloc_int(dev));
alloc_field(o,val_id("ino"),alloc_int(0));
int mode = 0;
if ((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) mode |= _S_IFDIR;
if ((data.dwFileAttributes & FILE_ATTRIBUTE_OFFLINE) == 0) mode |= _S_IFREG;
mode |= _S_IREAD;
if ((data.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0) mode |= _S_IWRITE;
if ((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) mode |= _S_IEXEC;
alloc_field(o,val_id("mode"),alloc_int(mode));
alloc_field(o,val_id("nlink"),alloc_int(1));
alloc_field(o,val_id("rdev"),alloc_int(dev));
alloc_field(o,val_id("size"),alloc_int32(data.nFileSizeLow));
#else
gc_enter_blocking();
struct stat s;
if( stat(val_string(path),&s) != 0 )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
o = alloc_empty_object( );
STATF(gid);
STATF(uid);
STATF32(atime);
STATF32(mtime);
STATF32(ctime);
STATF(dev);
STATF(ino);
STATF(mode);
STATF(nlink);
STATF(rdev);
STATF(size);
#endif
return o;
#endif
}
static value unserialize_rec( sbuffer *b, value loader ) {
switch( read_char(b) ) {
case 'N':
return val_null;
case 'T':
return val_true;
case 'F':
return val_false;
case 'i':
return alloc_int(read_int(b));
case 'I':
return alloc_int32(read_int(b));
case 'f':
{
tfloat d;
read_str(b,sizeof(tfloat),&d);
return alloc_float(d);
}
case 's':
{
int l = read_int(b);
value v;
if( l < 0 || l > max_string_size )
ERROR();
v = alloc_empty_string(l);
add_ref(b,v);
read_str(b,l,(char*)val_string(v));
return v;
}
case 'o':
{
int f;
value o = alloc_object(NULL);
add_ref(b,o);
while( (f = read_int(b)) != 0 ) {
value fval = unserialize_rec(b,loader);
alloc_field(o,(field)f,fval);
}
switch( read_char(b) ) {
case 'p':
{
value v = unserialize_rec(b,loader);
if( !val_is_object(v) )
ERROR();
((vobject*)o)->proto = (vobject*)v;
}
break;
case 'z':
break;
default:
ERROR();
}
return o;
}
case 'r':
{
int n = read_int(b);
if( n < 0 || n >= b->nrefs )
ERROR();
return b->trefs[b->nrefs - n - 1];
}
case 'a':
{
int i;
int n = read_int(b);
value o;
value *t;
if( n < 0 || n > max_array_size )
ERROR();
o = alloc_array(n);
t = val_array_ptr(o);
add_ref(b,o);
for(i=0;i<n;i++)
t[i] = unserialize_rec(b,loader);
return o;
}
case 'p':
{
int nargs = read_int(b);
vfunction *f = (vfunction*)alloc_function((void*)1,nargs,NULL);
vfunction *f2;
value name;
add_ref(b,(value)f);
name = unserialize_rec(b,loader);
f2 = (vfunction*)val_ocall2(loader,id_loadprim,name,alloc_int(nargs));
if( !val_is_function(f2) || val_fun_nargs(f2) != nargs )
failure("Loader returned not-a-function");
f->t = f2->t;
f->addr = f2->addr;
f->module = f2->module;
return (value)f;
}
case 'L':
{
vfunction *f = (vfunction*)alloc_function((void*)1,0,NULL);
value mname;
int pos;
int nargs;
value env;
add_ref(b,(value)f);
mname = unserialize_rec(b,loader);
pos = read_int(b);
nargs = read_int(b);
env = unserialize_rec(b,loader);
if( !val_is_array(env) )
ERROR();
{
value exp = val_ocall2(loader,id_loadmodule,mname,loader);
value mval;
unsigned int i;
int_val *mpos;
neko_module *m;
if( !val_is_object(exp) ) {
buffer b = alloc_buffer("module ");
val_buffer(b,mname);
buffer_append(b," is not an object");
bfailure(b);
}
mval = val_field(exp,id_module);
if( !val_is_kind(mval,neko_kind_module) ) {
buffer b = alloc_buffer("module ");
val_buffer(b,mname);
buffer_append(b," has invalid type");
bfailure(b);
}
m = (neko_module*)val_data(mval);
mpos = m->code + pos;
for(i=0;i<m->nglobals;i++) {
vfunction *g = (vfunction*)m->globals[i];
if( val_is_function(g) && g->addr == mpos && g->module == m && g->nargs == nargs ) {
f->t = VAL_FUNCTION;
f->env = env;
f->addr = mpos;
f->nargs = nargs;
f->module = m;
return (value)f;
}
}
{
buffer b = alloc_buffer("module ");
val_buffer(b,mname);
buffer_append(b," has been modified");
bfailure(b);
}
}
return val_null;
}
case 'x':
{
value mname = unserialize_rec(b,loader);
value data = unserialize_rec(b,loader);
value exports = val_ocall2(loader,id_loadmodule,mname,loader);
value s;
if( !val_is_object(exports) ) {
buffer b = alloc_buffer("module ");
val_buffer(b,mname);
buffer_append(b," is not an object");
bfailure(b);
}
s = val_field(exports,id_unserialize);
if( !val_is_function(s) || (val_fun_nargs(s) != 1 && val_fun_nargs(s) != VAR_ARGS) ) {
buffer b = alloc_buffer("module ");
val_buffer(b,mname);
buffer_append(b," has invalid __unserialize function");
}
s = val_call1(s,data);
add_ref(b,s);
return s;
}
case 'h':
{
int i;
vhash *h = (vhash*)alloc(sizeof(vhash));
h->ncells = read_int(b);
h->nitems = read_int(b);
h->cells = (hcell**)alloc(sizeof(hcell*)*h->ncells);
for(i=0;i<h->ncells;i++)
h->cells[i] = NULL;
for(i=0;i<h->nitems;i++) {
hcell **p;
hcell *c = (hcell*)alloc(sizeof(hcell));
c->hkey = read_int(b);
c->key = unserialize_rec(b,loader);
c->val = unserialize_rec(b,loader);
c->next = NULL;
p = &h->cells[c->hkey % h->ncells];
while( *p != NULL )
p = &(*p)->next;
*p = c;
}
return alloc_abstract(k_hash,h);
}
default:
ERROR();
return val_null;
}
}
value api_alloc_int32(int arg1) { return alloc_int32(arg1); }