std::string levelfromfile(const char *filename)
{
// stdin is default
FILE * file = stdin;
// non-null overrides
if (filename != 0)
file = fopen(filename, "r");
if (file == NULL)
{
fprintf(stderr, "Failed to open file \"%s\"\n", filename);
return "";
}
// Make sure the file is closed on exit
AutoClose auto_close(file);
std::string s;
char c[2] = {fgetc(file), '\0'};
while (c[0] != EOF)
{
if (c[0] == '\r')
c[0] = '\n';
//putchar(c[0]);
s.append(c);
// Read character
c[0] = fgetc(file);
}
return s;
}
virtual ~z_lua_state()
{
if (auto_close())
{
close();
}
}
socket_t bind(unsigned short port)
{
initialize();
/*! create a new socket */
SOCKET sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == INVALID_SOCKET) THROW_RUNTIME_ERROR("cannot create socket");
AutoCloseSocket auto_close(sockfd);
/* When the server completes, the server socket enters a time-wait state during which the local
address and port used by the socket are believed to be in use by the OS. The wait state may
last several minutes. This socket option allows bind() to reuse the port immediately. */
#ifdef SO_REUSEADDR
{ int flag = true; ::setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&flag, sizeof(int)); }
#endif
/*! bind socket to port */
struct sockaddr_in serv_addr;
memset((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = (unsigned short) htons(port);
serv_addr.sin_addr.s_addr = INADDR_ANY;
if (::bind(sockfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) < 0)
THROW_RUNTIME_ERROR("binding to port "+std::to_string((long long)port)+" failed");
/*! listen to port, up to 5 pending connections */
if (::listen(sockfd,5) < 0)
THROW_RUNTIME_ERROR("listening on socket failed");
auto_close.sock = INVALID_SOCKET;
return (socket_t) new buffered_socket_t(sockfd);
}
socket_t connect(const char* host, unsigned short port)
{
initialize();
/*! create a new socket */
SOCKET sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == INVALID_SOCKET) THROW_RUNTIME_ERROR("cannot create socket");
AutoCloseSocket auto_close(sockfd);
/*! perform DNS lookup */
struct hostent* server = ::gethostbyname(host);
if (server == nullptr) THROW_RUNTIME_ERROR("server "+std::string(host)+" not found");
/*! perform connection */
struct sockaddr_in serv_addr;
memset((char*)&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = (unsigned short) htons(port);
memcpy((char*)&serv_addr.sin_addr.s_addr, (char*)server->h_addr, server->h_length);
if (::connect(sockfd,(struct sockaddr*) &serv_addr,sizeof(serv_addr)) < 0)
THROW_RUNTIME_ERROR("connection to "+std::string(host)+":"+std::to_string((long long)port)+" failed");
/*! enable TCP_NODELAY */
#ifdef TCP_NODELAY
{ int flag = 1; ::setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (const char*)&flag, sizeof(int)); }
#endif
/*! we do not want SIGPIPE to be thrown */
#ifdef SO_NOSIGPIPE
{ int flag = 1; setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, (const char*) &flag, sizeof(int)); }
#endif
auto_close.sock = INVALID_SOCKET;
return (socket_t) new buffered_socket_t(sockfd);
}
int m_tuplespace_get(tuplespace_t *ts, unsigned int nb_tuples,
opaque_tuple_t *tuples){
#ifndef SMART_GET
int internal_nmbr = m_retrieve();
pthread_mutex_lock(&ts->mutex);
for(;;){
int internal_id = ts->binds[internal_nmbr];
int nb_internals = ts->nb_internals;
if(internal_id == -1)
internal_id = next_internal(ts, internal_id);
for(int count = 0; count < nb_internals && ts->nb_tuples; count++){
internal_t *i = &ts->internals[internal_id];
if(!m_internal_empty(i)){
int nb_out_tuples =
m_internal_iget(i, nb_tuples, tuples);
if(nb_out_tuples > 0){
change_nb_tuples(ts, -(nb_out_tuples));
pthread_mutex_unlock(&ts->mutex);
return nb_out_tuples;
}
}
internal_id = next_internal(ts, internal_id);
}
/* Reach if no tuples are available nowhere */
if(m_tuplespace_closed(ts)){
pthread_mutex_unlock(&ts->mutex);
return TUPLESPACE_CLOSED;
}
if(TUPLESPACE_OPTIONAUTOCLOSE & ts->options){
if(auto_close(ts) == TUPLESPACE_CLOSED){
pthread_mutex_unlock(&ts->mutex);
return TUPLESPACE_CLOSED;
}
}
else
pthread_cond_wait(&ts->cond, &ts->mutex);
}
#else
for(;;){
int internal_nmbr = m_retrieve();
int internal_id = ts->binds[internal_nmbr];
/* while there are some tuples */
while(__sync_fetch_and_or(&ts->nb_tuples, 0)){
internal_t *i = &ts->internals[internal_id];
assert(internal_id != -1);
if(!m_internal_empty(i)){
int nb_out_tuples =
m_internal_iget(i, nb_tuples, tuples);
if(nb_out_tuples > 0){
pthread_mutex_lock(&ts->mutex);
change_nb_tuples(ts, -(nb_out_tuples));
pthread_mutex_unlock(&ts->mutex);
return nb_out_tuples;
}
}
if((internal_id = next_internal(ts, internal_id)) == -1)
break;
}
/* Reached if there are no avaible tuples or internals */
pthread_mutex_lock(&ts->mutex);
while(ts->nb_tuples == 0){
//printf("%d enters locked mode\n", m_thread_id());
if(m_tuplespace_closed(ts)){
pthread_mutex_unlock(&ts->mutex);
return TUPLESPACE_CLOSED;
}
if(TUPLESPACE_OPTIONAUTOCLOSE & ts->options)
auto_close(ts);
else
pthread_cond_wait(&ts->cond, &ts->mutex);
}
pthread_mutex_unlock(&ts->mutex);
}
#endif //SMART_GET
}
