예제 #1
0
파일: File.cpp 프로젝트: bjitivo/hxcpp
/**
	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);
}
예제 #2
0
/**
	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
}
예제 #3
0
파일: Sys.cpp 프로젝트: Draknek/hxcpp
/**
	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
}
예제 #4
0
/**
	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;
}
예제 #5
0
/**
	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
}
예제 #6
0
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);
}
예제 #7
0
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);
}
예제 #8
0
/**
	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);
}
예제 #9
0
파일: Process.cpp 프로젝트: delahee/hxlibc
/**
   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
}
예제 #10
0
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);
}
예제 #11
0
파일: File.cpp 프로젝트: bjitivo/hxcpp
/**
	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);
			return alloc_int(size);
		}
		p += d;
		len -= d;
	}
	gc_exit_blocking();
	return n;
}
예제 #12
0
파일: Process.cpp 프로젝트: delahee/hxlibc
/**
   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
}
예제 #13
0
파일: Sys.cpp 프로젝트: Draknek/hxcpp
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);
}
예제 #14
0
/**
	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);
}
예제 #15
0
파일: Sys.cpp 프로젝트: Draknek/hxcpp
/**
	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
}
예제 #16
0
파일: Sys.cpp 프로젝트: Draknek/hxcpp
/**
	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
}
예제 #17
0
/**
	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);
}
예제 #18
0
파일: Socket.cpp 프로젝트: flowplay/hxcpp
/**
	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 );
}
예제 #19
0
파일: Context.cpp 프로젝트: boorik/hxzmq
// 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));
	}
}
예제 #20
0
/**
	sys_exists : string -> bool
	<doc>Returns true if the file or directory exists.</doc>
**/
static value sys_exists( value path ) {
	#if defined(EPPC) || defined(KORE_CONSOLE)
	return alloc_bool(true);
	#else
	val_check(path,string);
	#ifdef NEKO_WINDOWS
	const wchar_t* _path = val_wstring(path);
	gc_enter_blocking();
	bool result =  GetFileAttributesW(_path) != INVALID_FILE_ATTRIBUTES;
	#else
	struct stat st;
	gc_enter_blocking();
	bool result =  stat(val_string(path),&st) == 0;
	#endif
	gc_exit_blocking();
	return alloc_bool(result);
	#endif
}
예제 #21
0
/**
	sys_remove_dir : string -> void
	<doc>Remove a directory. Exception on error</doc>
**/
static value sys_remove_dir( value path ) {
	#if defined(EPPC) || defined(KORE_CONSOLE)
	return alloc_bool(true);
	#else
	val_check(path,string);
	#ifdef NEKO_WINDOWS
	const wchar_t* _path = val_wstring(path);
	gc_enter_blocking();
	bool ok = _wrmdir(_path) != 0;
	#else
	const char* _path = val_string(path);
	gc_enter_blocking();
	bool ok = rmdir(_path) != 0;
	#endif
	gc_exit_blocking();
	return alloc_bool(ok);
	#endif
}
예제 #22
0
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();
}
예제 #23
0
파일: File.cpp 프로젝트: bjitivo/hxcpp
/**
	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);
}
예제 #24
0
/**
	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);
}
예제 #25
0
파일: Sys.cpp 프로젝트: cunwaitaoshu/hxcpp
/**
	sys_remove_dir : string -> void
	<doc>Remove a directory. Exception on error</doc>
**/
static value sys_remove_dir( value path ) {
	#ifdef EPPC
	return alloc_bool(true);
	#else
	val_check(path,string);
	gc_enter_blocking();
	bool ok = rmdir(val_string(path)) != 0;
	gc_exit_blocking();
	return alloc_bool(ok);
	#endif
}
예제 #26
0
파일: File.cpp 프로젝트: bjitivo/hxcpp
/**
	file_seek : 'file -> pos:int -> mode:int -> void
	<doc>Use [fseek] to move the file pointer.</doc>
**/
static value file_seek( value o, value pos, value kind ) {
	fio *f;
	val_check_kind(o,k_file);
	val_check(pos,int);
	val_check(kind,int);
	f = val_file(o);
	gc_enter_blocking();
	if( fseek(f->io,val_int(pos),val_int(kind)) != 0 )
		file_error("file_seek",f);
	gc_exit_blocking();
	return alloc_bool(true);
}
예제 #27
0
static value socket_accept( value o ) {
	SOCKET sock = val_sock(o);
	struct sockaddr_in addr;
	SockLen addrlen = sizeof(addr);
	SOCKET s;
	gc_enter_blocking();
	s = accept(sock,(struct sockaddr*)&addr,&addrlen);
	if( s == INVALID_SOCKET )
		return block_error();
	gc_exit_blocking();
	return alloc_abstract(k_socket,(void *)(socket_int)s);
}
예제 #28
0
파일: Sys.cpp 프로젝트: Draknek/hxcpp
/**
	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);
}
예제 #29
0
파일: Sys.cpp 프로젝트: Draknek/hxcpp
/**
	sys_exists : string -> bool
	<doc>Returns true if the file or directory exists.</doc>
**/
static value sys_exists( value path ) {
	#ifdef EPPC
	return alloc_bool(true);
	#else
	struct stat st;
	val_check(path,string);
	gc_enter_blocking();
	bool result =  stat(val_string(path),&st) == 0;
	gc_exit_blocking();
	return alloc_bool(result);
	#endif
}
예제 #30
0
파일: File.cpp 프로젝트: bjitivo/hxcpp
/**
	file_tell : 'file -> int
	<doc>Return the current position in the file</doc>
**/
static value file_tell( value o ) {
	int p;
	fio *f;
	val_check_kind(o,k_file);
	f = val_file(o);
	gc_enter_blocking();
	p = ftell(f->io);
	if( p == -1 )
		file_error("file_tell",f);
	gc_exit_blocking();
	return alloc_int(p);
}