/**
process_stdout_read : 'process -> buf:string -> pos:int -> len:int -> int
<doc>
Read up to [len] bytes in [buf] starting at [pos] from the process stdout.
Returns the number of bytes readed this way. Raise an exception if this
process stdout is closed and no more data is available for reading.
For hxcpp, the input buffer is in bytes, not characters
</doc>
**/
static value process_stdout_read( value vp, value str, value pos, value len ) {
CHECK_ARGS();
gc_enter_blocking();
# ifdef NEKO_WINDOWS
{
DWORD nbytes;
if( !ReadFile(p->oread,buffer_data(buf)+val_int(pos),val_int(len),&nbytes,NULL) )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
return alloc_int(nbytes);
}
# else
int nbytes = read(p->oread,buffer_data(buf) + val_int(pos),val_int(len));
if( nbytes <= 0 )
{
gc_exit_blocking();
alloc_null();
}
gc_exit_blocking();
return alloc_int(nbytes);
# endif
}
/**
socket_set_timeout : 'socket -> timout:number? -> void
<doc>Set the socket send and recv timeout in seconds to the given value (or null for blocking)</doc>
**/
static value socket_set_timeout( value o, value t ) {
SOCKET sock = val_sock(o);
#ifdef NEKO_WINDOWS
int time;
if( val_is_null(t) )
time = 0;
else {
val_check(t,number);
time = (int)(val_number(t) * 1000);
}
#else
struct timeval time;
if( val_is_null(t) ) {
time.tv_usec = 0;
time.tv_sec = 0;
} else {
val_check(t,number);
init_timeval(val_number(t),&time);
}
#endif
gc_enter_blocking();
if( setsockopt(sock,SOL_SOCKET,SO_SNDTIMEO,(char*)&time,sizeof(time)) != 0 )
{
gc_exit_blocking();
return alloc_null();
}
if( setsockopt(sock,SOL_SOCKET,SO_RCVTIMEO,(char*)&time,sizeof(time)) != 0 )
{
gc_exit_blocking();
return alloc_null();
}
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
}
/**
file_contents : f:string -> string
<doc>Read the content of the file [f] and return it.</doc>
**/
static value file_contents( value name ) {
buffer s;
int len;
int p;
val_check(name,string);
fio f(val_filename(name));
const char *fname = val_string(name);
gc_enter_blocking();
f.io = fopen(fname,"rb");
if( f.io == NULL )
file_error("file_contents",&f);
fseek(f.io,0,SEEK_END);
len = ftell(f.io);
fseek(f.io,0,SEEK_SET);
gc_exit_blocking();
s = alloc_buffer_len(len);
p = 0;
gc_enter_blocking();
while( len > 0 ) {
int d;
POSIX_LABEL(file_contents);
d = (int)fread((char*)buffer_data(s)+p,1,len,f.io);
if( d <= 0 ) {
HANDLE_FINTR(f.io,file_contents);
fclose(f.io);
file_error("file_contents",&f);
}
p += d;
len -= d;
}
fclose(f.io);
gc_exit_blocking();
return buffer_val(s);
}
/**
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 ) {
#ifdef EPPC
return alloc_null();
#else
struct stat s;
value o;
val_check(path,string);
gc_enter_blocking();
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);
STATF(mode);
return o;
#endif
}
/**
sys_create_dir : string -> mode:int -> void
<doc>Create a directory with the specified rights</doc>
**/
static value sys_create_dir( value path, value mode ) {
#if defined(EPPC) || defined(KORE_CONSOLE)
return alloc_bool(true);
#else
val_check(path,string);
val_check(mode,int);
#ifdef NEKO_WINDOWS
const wchar_t* _path = val_wstring(path);
gc_enter_blocking();
if( _wmkdir(_path) != 0 )
{
gc_exit_blocking();
return alloc_null();
}
#else
const char* _path = val_string(path);
gc_enter_blocking();
if( mkdir(val_string(path),val_int(mode)) != 0 )
{
gc_exit_blocking();
return alloc_null();
}
#endif
gc_exit_blocking();
return alloc_bool(true);
#endif
}
/**
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);
}
static value sys_sleep( value f ) {
val_check(f,number);
gc_enter_blocking();
#if defined(NEKO_WINDOWS) && !defined(KORE_CONSOLE)
Sleep((DWORD)(val_number(f) * 1000));
#elif defined(EPPC) || defined(KORE_CONSOLE)
//TODO: Implement sys_sleep for EPPC
#else
{
struct timespec t;
struct timespec tmp;
t.tv_sec = (int)val_number(f);
t.tv_nsec = (int)((val_number(f) - t.tv_sec) * 1e9);
while( nanosleep(&t,&tmp) == -1 ) {
if( errno != EINTR ) {
gc_exit_blocking();
return alloc_null();
}
t = tmp;
}
}
#endif
gc_exit_blocking();
return alloc_bool(true);
}
/**
process_exit : 'process -> int
<doc>
Wait until the process terminate, then returns its exit code.
</doc>
**/
static value process_exit( value vp ) {
vprocess *p;
val_check_kind(vp,k_process);
p = val_process(vp);
gc_enter_blocking();
# ifdef NEKO_WINDOWS
{
DWORD rval;
WaitForSingleObject(p->pinf.hProcess,INFINITE);
gc_exit_blocking();
if( !GetExitCodeProcess(p->pinf.hProcess,&rval) )
return alloc_null();
return alloc_int(rval);
}
# else
int rval;
while( waitpid(p->pid,&rval,0) != p->pid ) {
if( errno == EINTR )
continue;
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
if( !WIFEXITED(rval) )
return alloc_null();
return alloc_int(WEXITSTATUS(rval));
# endif
}
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);
}
/**
file_read : 'file -> s:string -> p:int -> l:int -> int
<doc>
Read up to [l] chars into the string [s] starting at position [p].
Returns the number of chars readed which is > 0 (or 0 if l == 0).
</doc>
**/
static value file_read( value o, value s, value pp, value n ) {
fio *f;
int p;
int len;
int buf_len;
val_check_kind(o,k_file);
val_check(s,buffer);
buffer buf = val_to_buffer(s);
buf_len = buffer_size(buf);
val_check(pp,int);
val_check(n,int);
f = val_file(o);
p = val_int(pp);
len = val_int(n);
if( p < 0 || len < 0 || p > buf_len || p + len > buf_len )
return alloc_null();
gc_enter_blocking();
while( len > 0 ) {
int d;
POSIX_LABEL(file_read_again);
d = (int)fread(buffer_data(buf)+p,1,len,f->io);
if( d <= 0 ) {
int size = val_int(n) - len;
HANDLE_FINTR(f->io,file_read_again);
if( size == 0 )
file_error("file_read",f);
gc_exit_blocking();
return alloc_int(size);
}
p += d;
len -= d;
}
gc_exit_blocking();
return n;
}
/**
sys_file_type : string -> string
<doc>
Return the type of the file. The current values are possible :
<ul>
<li>[file]</li>
<li>[dir]</li>
<li>[symlink]</li>
<li>[sock]</li>
<li>[char]</li>
<li>[block]</li>
<li>[fifo]</li>
</ul>
</doc>
**/
static value sys_file_type( value path ) {
#ifdef EPPC
return alloc_null();
#else
struct stat s;
val_check(path,string);
gc_enter_blocking();
if( stat(val_string(path),&s) != 0 )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
if( s.st_mode & S_IFREG )
return alloc_string("file");
if( s.st_mode & S_IFDIR )
return alloc_string("dir");
if( s.st_mode & S_IFCHR )
return alloc_string("char");
#ifndef NEKO_WINDOWS
if( s.st_mode & S_IFLNK )
return alloc_string("symlink");
if( s.st_mode & S_IFBLK )
return alloc_string("block");
if( s.st_mode & S_IFIFO )
return alloc_string("fifo");
if( s.st_mode & S_IFSOCK )
return alloc_string("sock");
#endif
return alloc_null();
#endif
}
static value sys_sleep( value f ) {
val_check(f,number);
gc_enter_blocking();
#ifdef HX_WINRT
if (!tlsSleepEvent)
tlsSleepEvent = CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, EVENT_ALL_ACCESS);
WaitForSingleObjectEx(tlsSleepEvent, (int)(val_number(f)*1000), false);
#elif defined(NEKO_WINDOWS)
Sleep((DWORD)(val_number(f) * 1000));
#elif defined(EPPC)
//TODO: Implement sys_sleep for EPPC
#else
{
struct timespec t;
struct timespec tmp;
t.tv_sec = (int)val_number(f);
t.tv_nsec = (int)((val_number(f) - t.tv_sec) * 1e9);
while( nanosleep(&t,&tmp) == -1 ) {
if( errno != EINTR ) {
gc_exit_blocking();
return alloc_null();
}
t = tmp;
}
}
#endif
gc_exit_blocking();
return alloc_bool(true);
}
/**
socket_poll_events : 'poll -> timeout:float -> void
<doc>
Update the read/write flags arrays that were created with [socket_poll_prepare].
</doc>
**/
static value socket_poll_events( value pdata, value timeout ) {
polldata *p;
# ifdef NEKO_WINDOWS
unsigned int i;
int k = 0;
struct timeval t;
val_check_kind(pdata,k_poll);
p = val_poll(pdata);
memcpy(p->outr,p->fdr,FDSIZE(p->fdr->fd_count));
memcpy(p->outw,p->fdw,FDSIZE(p->fdw->fd_count));
val_check(timeout,number);
init_timeval(val_number(timeout),&t);
gc_enter_blocking();
if( p->fdr->fd_count + p->fdw->fd_count != 0 && select(0,p->outr,p->outw,NULL,&t) == SOCKET_ERROR )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
k = 0;
for(i=0;i<p->fdr->fd_count;i++)
if( FD_ISSET(p->fdr->fd_array[i],p->outr) )
val_array_set_i(p->ridx,k++,alloc_int(i));
val_array_set_i(p->ridx,k,alloc_int(-1));
k = 0;
for(i=0;i<p->fdw->fd_count;i++)
if( FD_ISSET(p->fdw->fd_array[i],p->outw) )
val_array_set_i(p->widx,k++, alloc_int(i));
val_array_set_i(p->widx,k,alloc_int(-1));
#else
int i,k;
int tot;
val_check_kind(pdata,k_poll);
val_check(timeout,number);
p = val_poll(pdata);
tot = p->rcount + p->wcount;
gc_enter_blocking();
POSIX_LABEL(poll_events_again);
if( poll(p->fds,tot,(int)(val_number(timeout) * 1000)) < 0 ) {
HANDLE_EINTR(poll_events_again);
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
k = 0;
for(i=0;i<p->rcount;i++)
if( p->fds[i].revents & (POLLIN|POLLHUP) )
val_array_set_i(p->ridx,k++,alloc_int(i));
val_array_set_i(p->ridx,k, alloc_int(-1));
k = 0;
for(;i<tot;i++)
if( p->fds[i].revents & (POLLOUT|POLLHUP) )
val_array_set_i(p->widx,k++, alloc_int(i - p->rcount));
val_array_set_i(p->widx,k, alloc_int(-1));
#endif
return val_null;
}
/**
host_local : void -> string
<doc>Return the local host name.</doc>
**/
static value host_local() {
char buf[256];
gc_enter_blocking();
if( gethostname(buf,256) == SOCKET_ERROR )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
return alloc_string(buf);
}
/**
sys_rename : from:string -> to:string -> void
<doc>Rename the file or directory. Exception on error.</doc>
**/
static value sys_rename( value path, value newname ) {
val_check(path,string);
val_check(newname,string);
gc_enter_blocking();
if( rename(val_string(path),val_string(newname)) != 0 )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
return alloc_bool(true);
}
/**
socket_listen : 'socket -> int -> void
<doc>Listen for a number of connections</doc>
**/
static value socket_listen( value o, value n ) {
SOCKET sock = val_sock(o);
val_check(n,int);
gc_enter_blocking();
if( listen(sock,val_int(n)) == SOCKET_ERROR )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
return alloc_bool(true);
}
/**
sys_file_type : string -> string
<doc>
Return the type of the file. The current values are possible :
<ul>
<li>[file]</li>
<li>[dir]</li>
<li>[symlink]</li>
<li>[sock]</li>
<li>[char]</li>
<li>[block]</li>
<li>[fifo]</li>
</ul>
</doc>
**/
static value sys_file_type( value path ) {
#if defined(EPPC) || defined(KORE_CONSOLE)
return alloc_null();
#else
val_check(path,string);
#ifdef NEKO_WINDOWS
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();
if ((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
{
return alloc_string("dir");
}
else
{
return alloc_string("file");
}
#else
struct stat s;
gc_enter_blocking();
if( stat(val_string(path),&s) != 0 )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
if( s.st_mode & S_IFREG )
return alloc_string("file");
if( s.st_mode & S_IFDIR )
return alloc_string("dir");
if( s.st_mode & S_IFCHR )
return alloc_string("char");
#ifndef NEKO_WINDOWS
if( s.st_mode & S_IFLNK )
return alloc_string("symlink");
if( s.st_mode & S_IFBLK )
return alloc_string("block");
if( s.st_mode & S_IFIFO )
return alloc_string("fifo");
if( s.st_mode & S_IFSOCK )
return alloc_string("sock");
#endif
#endif
return alloc_null();
#endif
}
/**
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);
}
/**
file_delete : string -> void
<doc>Delete the file. Exception on error.</doc>
**/
static value file_delete( value path ) {
#ifdef EPPC
return alloc_bool(true);
#else
val_check(path,string);
gc_enter_blocking();
if( unlink(val_string(path)) != 0 )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
return alloc_bool(true);
#endif
}
/**
socket_send_to : 'socket -> buf:string -> pos:int -> length:int -> addr:{host:'int32,port:int} -> int
<doc>
Send data from an unconnected UDP socket to the given address.
</doc>
**/
static value socket_send_to( value o, value dataBuf, value pos, value len, value vaddr ) {
int p,l;
value host, port;
struct sockaddr_in addr;
val_check_kind(o,k_socket);
buffer buf = val_to_buffer(dataBuf);
const char *cdata = buffer_data(buf);
int dlen = buffer_size(buf);
val_check(pos,int);
val_check(len,int);
val_check(vaddr,object);
host = val_field(vaddr, f_host);
port = val_field(vaddr, f_port);
val_check(host,int);
val_check(port,int);
p = val_int(pos);
l = val_int(len);
memset(&addr,0,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(val_int(port));
*(int*)&addr.sin_addr.s_addr = val_int(host);
if( p < 0 || l < 0 || p > dlen || p + l > dlen )
neko_error();
SOCKET sock = val_sock(o);
gc_enter_blocking();
POSIX_LABEL(send_again);
dlen = sendto(sock, cdata + p , l, MSG_NOSIGNAL, (struct sockaddr*)&addr, sizeof(addr));
if( dlen == SOCKET_ERROR ) {
HANDLE_EINTR(send_again);
return block_error();
}
gc_exit_blocking();
return alloc_int(dlen);
}
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 -> string
<doc>Resolve the given host string into an IP address.</doc>
**/
static value host_resolve( value host ) {
char address[INET6_ADDRSTRLEN];
val_check(host,string);
gc_enter_blocking();
const char *hostName = val_string(host);
struct addrinfo* addr_result;
int result = getaddrinfo(hostName, NULL, NULL, &addr_result);
if (result == 0) {
if (addr_result->ai_family == AF_INET) {
inet_ntop(AF_INET,
&((struct sockaddr_in *)addr_result->ai_addr)->sin_addr,
address,
sizeof(address));
}
else {
inet_ntop(AF_INET6,
&((struct sockaddr_in6 *)addr_result->ai_addr)->sin6_addr,
address,
sizeof(address));
}
freeaddrinfo(addr_result);
}
gc_exit_blocking();
return alloc_string( address );
}
/**
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;
gc_enter_blocking();
if( getsockname(sock,(struct sockaddr*)&addr,&addrlen) == SOCKET_ERROR )
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
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;
}
/**
process_stdin_write : 'process -> buf:string -> pos:int -> len:int -> int
<doc>
Write up to [len] bytes from [buf] starting at [pos] to the process stdin.
Returns the number of bytes writen this way. Raise an exception if this
process stdin is closed.
</doc>
**/
static value process_stdin_write( value vp, value str, value pos, value len ) {
CHECK_ARGS();
gc_enter_blocking();
# ifdef NEKO_WINDOWS
DWORD nbytes;
if( !WriteFile(p->iwrite,buffer_data(buf)+val_int(pos),val_int(len),&nbytes,NULL) )
# else
int nbytes = write(p->iwrite,buffer_data(buf)+val_int(pos),val_int(len));
if( nbytes == -1 )
# endif
{
gc_exit_blocking();
return alloc_null();
}
gc_exit_blocking();
return alloc_int(nbytes);
}
/**
socket_connect : 'socket -> host:'int32 -> port:int -> void
<doc>Connect the socket the given [host] and [port]</doc>
**/
static value socket_connect( value o, value host, value port ) {
struct sockaddr_in addr;
val_check(host,int);
val_check(port,int);
memset(&addr,0,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(val_int(port));
*(int*)&addr.sin_addr.s_addr = val_int(host);
gc_enter_blocking();
if( connect(val_sock(o),(struct sockaddr*)&addr,sizeof(addr)) != 0 )
{
gc_exit_blocking();
val_throw(alloc_string("std@socket_connect"));
}
gc_exit_blocking();
return alloc_bool(true);
}
// Finalizer for context
void finalize_context( value v) {
gc_enter_blocking();
int ret = zmq_term( val_data(v));
gc_exit_blocking();
if (ret != 0) {
int err = zmq_errno();
val_throw(alloc_int(err));
}
}
static void file_error( const char *msg, fio *f, bool delete_f = false ) {
gc_exit_blocking();
value a = alloc_array(2);
val_array_set_i(a,0,alloc_string(msg));
val_array_set_i(a,1,alloc_filename(f->name.c_str()));
if (delete_f)
delete f;
val_throw(a);
}
value socket_set_fast_send( value o, value b )
{
SOCKET sock = val_sock(o);
val_check(b,bool);
int fast = val_bool(b);
gc_enter_blocking();
setsockopt(sock,IPPROTO_TCP,TCP_NODELAY,(char*)&fast,sizeof(fast));
gc_exit_blocking();
return alloc_null();
}
/**
file_flush : 'file -> void
<doc>Flush the file buffer</doc>
**/
static value file_flush( value o ) {
fio *f;
val_check_kind(o,k_file);
f = val_file(o);
gc_enter_blocking();
if( fflush( f->io ) != 0 )
file_error("file_flush",f);
gc_exit_blocking();
return alloc_bool(true);
}
