Anubis / Anubis

/* vmtools.c ****************************************************

   Anubis
   Some useful tools to put virtual machines at work

 ****************************************************************/

#include "AnubisSupport.h"
//#include <malloc.h>
#include <stdio.h>
#include <assert.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
#include <string.h>
#include "bytecode.h"
#include "vm.h"
#include "dependencies.h"
#include "DebugLog.h"
#include "../../../third_dev/sqlite3/sqlite3.h"
#include "CMList.h"
#include "graphics.h"
#include "Library.h"

#ifdef WITH_SQLAPI
#include "SQLAPI.h"
#endif

#if defined (_LINUX_) || (__BEOS__)
#include <netdb.h>
#endif
#include "AnubisSupport.h"

U32 max_memory = 60<<20;
U32 current_memory = 0;

U32 default_stack_size = 50;        /* does need to be big */ 
U32 stack_more_size = 50;           /* idem */ 
U32 stack_per_machine = 1<<20;      /* maximum */

//#define RELLOC(ptr, code) do { (((U32 *)ptr))[0] += (U32)code; ptr += sizeof(U32);} while(0)
#define RELLOC(ptr, code) do { void* s = code+*(U32*)ptr; memcpy(ptr, &s, sizeof(U32)); ptr += sizeof(U32);} while(0)


#ifdef WIN32
#include <sys/timeb.h>
#include <time.h>
#include <conio.h>

/* emulation of 'gettimeofday' for Windows */
int gettimeofday (struct timeval *TP, struct timezone *TZP)
{
  struct timeb timebuf;
  ftime (&timebuf);
  TP->tv_sec = timebuf.time;
  TP->tv_usec = (long)(timebuf.millitm) * (1000);

  return 0;
}

int settimeofday(const struct timeval *tp, const struct timezone *tzp)
{

  if (tp->tv_sec < 0)
  {
    return -1;
  }

  struct tm * new_time = gmtime((const time_t *)&tp->tv_sec);
  SYSTEMTIME lpSystemTime;

  if(new_time)
  {
    lpSystemTime.wHour    = new_time->tm_hour;
    lpSystemTime.wMinute  = new_time->tm_min;
    lpSystemTime.wSecond  = new_time->tm_sec;
    lpSystemTime.wDay     = new_time->tm_mday;
    lpSystemTime.wMonth   = new_time->tm_mon + 1;
    lpSystemTime.wYear    = new_time->tm_year + 1900;
    lpSystemTime.wMilliseconds  = tp->tv_usec / 1000;
    lpSystemTime.wDayOfWeek= 0;

    if(SetSystemTime(&lpSystemTime))
    {
      return 0;
    }
    /*else
    {
      DWORD error = GetLastError();
    }*/
  }

  return -1;
}

#endif


/*
   This list contains all references (of  type (void *)) to SQLite3 database handles which
   are no more  referenced by Anubis (in other words, the  garbage-collector of Anubis has
   decremented  the counter (in the +++StructPtr(SQLite3))  down  to 0  for this  database
   handle).

   However, the  handle is not closed  because it is  referenced to from within  a SQLite3
   statement. The SQLite3 primitive 'sqlite3_close' denies to close the handle if there is
   still a  reference like  this one,  and this  can be tested  when we  try to  close the
   database handle.

   Database handles in this list will be called 'candidates for closing'.
 */
List SqliteCloseList;


#ifdef _LINUX_
void host_free_child_pid(pid_t pid)
{
  /* Actually, 'ptr' is of type 'pid_t'*/
}
#endif
#ifdef WIN32
void host_free_child_pid(pid_t pid)
{
  /* Actually, 'ptr' is of type 'pid_t'*/
}
#endif

#ifdef _LINUX_  //emulation of getch for Linux
#include <termios.h>

static struct termios initial_settings, new_settings;
static int peek_character = -1;

void init_keyboard()
{
    tcgetattr(0,&initial_settings);
    new_settings = initial_settings;
    new_settings.c_lflag &= ~ICANON;
    new_settings.c_lflag &= ~ECHO;
    new_settings.c_lflag &= ~ISIG;
    new_settings.c_cc[VMIN] = 1;
    new_settings.c_cc[VTIME] = 0;
    tcsetattr(0, TCSANOW, &new_settings);
}

void close_keyboard()
{
    tcsetattr(0, TCSANOW, &initial_settings);
}

int kbhit()
{
    unsigned char ch;
    int nread;

    if (peek_character != -1)
        return 1;

    new_settings.c_cc[VMIN]=0;
    tcsetattr(0, TCSANOW, &new_settings);
    nread = read(0,&ch,1);
    new_settings.c_cc[VMIN]=1;
    tcsetattr(0, TCSANOW, &new_settings);
    if(nread == 1)
    {
        peek_character = ch;
        return 1;
    }

    return 0;
}

int getch()
{
    char ch;

    if(peek_character != -1)
    {
        ch = peek_character;
        peek_character = -1;
        return ch;
    }
    (void)read(0,&ch,1);
    return ch;
}
#endif



void free_C_structure(void *ptr, U8 struct_id, AnubisAllocator *allocator)
{
  U32 sqlite_result;

  switch(struct_id)
  {

#ifdef _WITH_SSL_
    case C_struct_id_SSL:
      SSL_shutdown((SSL *)ptr);
      SSL_free((SSL *)ptr);
      return;
    case C_struct_id_X509:
      X509_free((X509 *)ptr);
      return;
#endif /* _WITH_SSL_ */

#ifdef _WITH_GRAPHISM_
    case C_struct_id_HostWindow:
      host_free_host_window((U32)ptr);
      return;
    case C_struct_id_HostGC:
      host_free_host_gc((U32)ptr);
      return;
    case C_struct_id_HostImage:
      host_free_host_pixmap((U32)ptr);
      return;
#endif  /* _WITH_GRAPHISM_ */

    case C_struct_id_SysFont:
      free_load_sf_font(100,NULL,(Font1)ptr);
      return;

    case C_struct_id_Exec:
      host_free_child_pid((pid_t)ptr);
      return;

      /* SQLite3 */
    case C_struct_id_SQLite3:
      /*
         We are  here because the garbage-collector  of Anubis has decremented  down to 0
         the counter for the database handle 'ptr'. If this handle cannot be closed, this
         means  that there  is still  at  least one  SQLite3 statement  referring to  this
         database handle. In this case the handle  must be added to the list, and becomes
         a 'candidate for closing'.
       */
      sqlite_result = sqlite3_close((sqlite3 *)ptr);
      if(sqlite_result != SQLITE_OK)
      {
        //LOGINFO("SQLITE_DB must be [%d] Close \n",ptr);
        SqliteCloseList.AddItem(ptr);

      }
      return;

    case C_struct_id_SQLite3Stmt:
      {
        /*
           Get the database handle for this SQLite3 statement, and close the statement.
         */
        sqlite3 * his_db = sqlite3_db_handle((sqlite3_stmt*)ptr);
        sqlite_result = sqlite3_finalize((sqlite3_stmt *)ptr);
        /*
           If the  database handle is  a candidate for  closing, try to  close it. If  it is
           possible, there is  no more statement refering to it, and  the database handle is
           no more a candidate for closing. In this case, it must be removed from the list.
         */
        if(SqliteCloseList.HasItem(his_db))
        {
          sqlite_result = sqlite3_close((sqlite3 *)his_db);
          if (sqlite_result == SQLITE_OK)
          {
            //LOGINFO("SQLITE_DB [%d] has closed \n",his_db);
            SqliteCloseList.RemoveItem(his_db);
            //int count = SqliteCloseList.GetCount();
            //LOGINFO("SQLITE_DB CloseList has %d items\n",SqliteCloseList.GetCount());

          }
        }
        return;
      }

    case C_struct_id_Opaque:
      {
        /* ptr points to a segment allocated by the VM, and containing:
           offset 0:    deletion function of type void f(void *)
           offset 4:    number of data bytes
           offset 8:    data bytes
         */
        void (*delfunc)(void *) = (void (*)(void *))(((U32 *)ptr)[0]);   /* get the deletion function */
        if (*delfunc) { (*delfunc)((void *)(((U8 *)ptr)+4)); }           /* apply it (if function exists) */
        allocator->FreeDataSegment((U32 *)ptr);                          /* delete the segment */
        return;
      }


    case C_struct_id_Library:
      {
        Library * lib = (Library*)ptr;
        SAFE_DELETE(lib);
      }
      return;

      /* DBAPI */
    case C_struct_id_DB:
      {
#ifdef WITH_SQLAPI
        SAConnection *cnx = (SAConnection*)ptr;
        SAFE_DELETE(cnx);
#endif
        return;
      }

    case C_struct_id_DbStmt:
      {
#ifdef WITH_SQLAPI
        SACommand *cmd = (SACommand*)ptr;
        SAFE_DELETE(cmd);
#endif
        return;
      }

    default:
      assert(0);
  }
}


char *name_from_path(char *path)
{
  U32 i = 0;

  while(path[i] != 0) i++;  /* go the the end of path */
  while (i > 0 && path[i] != '/' && path[i] != '\\') i--;
  if (i == 0)
    return path;
  else
    return (path+i+1);
}


U32 anubis_string_list_length(U32 l)
{
  U32 len = 0;
  while (l != 0)
  {
    len++;
    l = *(((U32 *)(l&pointer_mask))+2);    /* tail of list */
  }
  return len;
}




const char *work_sort_string[] =
{
#define item(n)  #n,
  work_sort_list
#undef item
    "unknown"
};


//extern struct Machine_struct machines[max_machine];





#ifdef instruction_count
void show_instruction_count(U32 mid, FILE *fp)
{
  U32 i;
  U32 total = 0;

  for (i = 0; i < i_dummy; i++)
  {
    fprintf(fp,"   %30s: %d\n",instr_names[i],(machines[mid].i_count)[i]);
    total += (machines[mid].i_count)[i];
  }
  fprintf(fp,"   %30s: %d\n","total",total);
}
#endif


#ifdef WIN32
#define is_invalid_socket(s)    ((s) == INVALID_SOCKET)
#else
#define is_invalid_socket(s)    ((s) < 0)
#endif





/*--- add a memory segment to an allocator ---------------------------------------------*/
//int enlarge_memory(Allocator allocator)
//{
//  U32 *new_segment;
//  //U32 *old_ffss;
//
//  /* get a new segment */
//  if ((new_segment = (U32 *)malloc((6+memory_seg_size)*sizeof(U32))) == NULL)
//    {
//      return 0;  /* go on waiting for memory... */
//    }
//
//  allocator->word_size += 6+memory_seg_size;
//
//  /* chain the new segment of memory to the machine */
//  new_segment[0] = (U32)(allocator->memory);
//  new_segment[1] = (U32)(allocator->memory);   /* duplicated chaining */
//  new_segment[2] = (U32)(allocator->memory);   /* duplicated chaining */
//  new_segment[3] = (U32)memory_seg_size;   /* size */
//  new_segment[4] = (U32)memory_seg_size;   /* duplicated */
//  new_segment[5] = (U32)memory_seg_size;   /* duplicated */
//  allocator->memory = new_segment;
//
//  /* update chain of free segments */
//  new_segment[6] = (U32)memory_seg_size;   /* size of new secondary segment */
//  new_segment[7] = (U32)(allocator->ffss); /* tail of secondary segment chain */
//  allocator->ffss = new_segment+6;
//
//#ifdef debug_vm
//  if (heap_test)
//    compute_memory_check_sums(allocator);
//#endif
//
//  return 1;
//}





/*--- enlarge a machine's stack -------------------------------------------------------*/
//void enlarge_machine_stack(int mid)    /* machine id */
//{
//  U32 *    stack         = machines[mid].SP_begin;
//  int      oldsize       = (machines[mid].SP_end) - (machines[mid].SP_begin);
//  U32      relative_SP   = (machines[mid].SP) - (machines[mid].SP_begin);
//  U32 *    new_stack;
//
//  assert(machines[mid].status == need_bigger_stack);
//
//  if (oldsize+stack_more_size > (stack_per_machine>>2))
//    {
//        {
//          if (current_memory+stack_more_size >= max_memory)
//            {
//              LOGINFO("The stack of machine number %d has reached the maximum\n|   allowed (%d bytes). This machine has been stopped.\n", mid,stack_per_machine);
//              machines[mid].status = finished;
//              return;
//            }
//        }
//    }
//
//  if ((new_stack = (U32 *)realloc(stack,(oldsize + stack_more_size)*sizeof(U32))) == NULL)
//    return; /* go on waiting for stack memory... */
//
//  /* the stack has been successfully reallocated */
//  machines[mid].SP_begin = new_stack;
//  machines[mid].SP = new_stack+relative_SP;
//  machines[mid].SP_end = new_stack + oldsize + stack_more_size;
//
//  /* change machine's status */
//  machines[mid].status = running;
//
//  /*
//      printf("the stack of machine number %d has been enlarged (%d words --> %d words).\n",
//              mid,oldsize,oldsize+stack_more_size);
//  */
//}


//void enlarge_machine_locked_files_stack(int mid)
//{
//  U32 *      stack      = machines[mid].locked_files;
//  U32        oldsize    = machines[mid].locked_files_stack_size;
//  U32 *      new_stack;
//
//  assert(machines[mid].status == need_bigger_locked_files_stack);
//
//  if (oldsize+default_locked_files_stack_size > (stack_per_machine)>>4)
//    {
//      LOGINFO("The number of locked files for machine number %d too big.\n"
//             "|  This machine has been stopped.\n",mid);
//      machines[mid].status = finished;
//      return;
//    }
//
//  new_stack = (U32 *)realloc(stack,(oldsize+default_locked_files_stack_size)*sizeof(U32));
//  if (new_stack == NULL) return; /* wait ... */
//
//  /* then stack has been successfully reallocated */
//  machines[mid].locked_files = new_stack;
//  machines[mid].locked_files_stack_size += default_locked_files_stack_size;
//
//  /* let the scheduler restart this machine */
//  machines[mid].status = running;
//}
//

/* debugging tool */
//void test_memory_chain(Allocator allocator)
//{
//  U32 *aux;
//
//  aux = allocator->memory;
//
//  while (aux != NULL)
//    {
//      if (aux[0] != aux[1] || aux[0] != aux[2])
// {
//   LOGINFO("in test_memory_chain: aux[0] == %.8x, aux[1] == %.8x, aux[2] == %.8x\n",
//   aux[0], aux[1], aux[2]);
//   my_exit(3);
// }
//      if (aux[3] != aux[4] || aux[3] != aux[5])
// {
//   LOGINFO("in test_memory_chain: aux[3] == %.8x, aux[4] == %.8x, aux[5] == %.8x\n",
//   aux[3], aux[4], aux[5]);
//   my_exit(3);
// }
//      aux = (U32 *)aux[0];
//    }
//}




//void check_segments_sizes(Allocator allocator)
//{
//  U32 * ptr = allocator->ffss;
//  while (ptr != NULL)
//    {
//      assert(ptr[0] <= memory_seg_size);
//      ptr = (U32 *)(ptr[1]);
//    }
//}


//void check_memory_pointers(Allocator allocator)
//{
//  int dummy;
//  U32 *mem;
//  U32 *ptr = allocator->ffss;
//  int checked;
//
//  while (ptr != NULL)
//    {
//      checked = 0;
//      mem = allocator->memory;
//      while (mem != NULL)
// {
//   if (mem <= ptr && ptr <= mem+mem[3])
//     { checked = 1; break; }
//   mem = (U32 *)(mem[0]);
// }
//      if (!checked)
// {
//   LOGINFO("\ncheck_memory_pointers: failed");
//   fflush(stdout);
//   dummy = ((char *)0)[0];
// }
//      ptr = (U32 *)(ptr[1]);
//    }
//}



//void show_heap(Allocator allocator)
//{
//  U32 *ptr = allocator->ffss;
//
//  LOGINFO("\n ---- heap ---- heap ----");
//  while (ptr != NULL)
//    {
//      LOGINFO("\n heap: %p %u",ptr,ptr[0]);
//      ptr = (U32 *)(ptr[1]);
//    }
//  LOGINFO("\n ---- heap ---- heap ----");
//}

//#ifdef debug_vm
//void compute_memory_check_sums(Allocator allocator)
//{
//  U32 seg_num = 0;
//  U32 size_sum = 0;
//  U32 ptr_sum = 0;
//  U32 *ptr = allocator->ffss;
//
//  while (ptr != NULL)
//    {
//      seg_num++;
//      size_sum += ptr[0];
//      ptr_sum += (U32)(ptr);
//      ptr = (U32 *)(ptr[1]);
//    }
//  allocator->ffss_seg_num = seg_num;
//  allocator->ffss_size_sum = size_sum;
//  allocator->ffss_ptr_sum = ptr_sum;
//}
//
//#endif

///* Compute the size of the free storage chain */
//U32 storage_chain_words(Allocator allocator)
//{
//  U32 result = 0;
//  U32 *ptr = allocator->ffss;
//
//  while(ptr != NULL)
//    {
//      result += ptr[0];
//      ptr = (U32 *)(ptr[1]);
//    }
//  return result;
//}
//

#ifdef debug_vm
//void test_memory_check_sums(Allocator allocator)
//{
//  U32 seg_num = 0;
//  U32 size_sum = 0;
//  U32 ptr_sum = 0;
//  U32 *ptr = allocator->ffss;
//  int dummy;
//  int count = 0;
//
//  while (ptr != NULL)
//    {
//      count++;
//      if (count > 10+(allocator->allocated_segments))
//        {
//          LOGINFO("\ntest_memory_check_sums: failed");
//          LOGINFO("\nincompatible number of allocated segments");
//          LOGINFO("\n(maybe a loop in free segments chain)");
//          LOGINFO("\nIP - code = %d\n",IPcode);
//          fflush(stdout);
//          dummy = ((char *)0)[0];
//        }
//      seg_num++;
//      size_sum += ptr[0];
//      ptr_sum += (U32)(ptr);
//      ptr = (U32 *)(ptr[1]);
//    }
//  if (
//      allocator->ffss_seg_num != seg_num ||
//      allocator->ffss_size_sum != size_sum ||
//      allocator->ffss_ptr_sum != ptr_sum)
//    {
//      LOGINFO("\ntest_memory_check_sums: failed");
//      LOGINFO("\nallocator->ffss_seg_num  = %20u computed: %20u",allocator->ffss_seg_num,seg_num);
//      LOGINFO("\nallocator->ffss_size_sum = %20u computed: %20u",allocator->ffss_size_sum,size_sum);
//      LOGINFO("\nallocator->ffss_ptr_sum  = %20u computed: %20u",allocator->ffss_ptr_sum,ptr_sum);
//      show_heap(allocator);
//      LOGINFO("\nIP - code = %d\n",IPcode);
//      fflush(stdout);
//      dummy = ((char *)0)[0];
//    }
//}


//void test_memory_check_sums_IP(Allocator allocator, int IPcode)
//{
//  U32 seg_num = 0;
//  U32 size_sum = 0;
//  U32 ptr_sum = 0;
//  U32 *ptr = allocator->ffss;
//  int dummy;
//
//  while (ptr != NULL)
//    {
//      /*
//      printf("\n ---- machine %d heap: %p %u",mid,ptr,ptr[0]);
//      fflush(stdout);
//      */
//      seg_num++;
//      size_sum += ptr[0];
//      ptr_sum += (U32)(ptr);
//      ptr = (U32 *)(ptr[1]);
//    }
//  if (
//      allocator->ffss_seg_num != seg_num ||
//      allocator->ffss_size_sum != size_sum ||
//      allocator->ffss_ptr_sum != ptr_sum)
//    {
//      LOGINFO("\ntest_memory_check_sums: failed");
//      LOGINFO("\nallocator->ffss_seg_num  = %20u computed: %20u",allocator->ffss_seg_num,seg_num);
//      LOGINFO("\nallocator->ffss_size_sum = %20u computed: %20u",allocator->ffss_size_sum,size_sum);
//      LOGINFO("\nallocator->ffss_ptr_sum  = %20u computed: %20u",allocator->ffss_ptr_sum,ptr_sum);
//      show_heap(allocator);
//      LOGINFO("\nIP - code = %d\n",IPcode);
//      fflush(stdout);
//      dummy = ((char *)0)[0];
//    }
//}
#endif


/*--- release a machine --------------------------------------------------*/
//void release_machine(int mid)
//{
//  assert(machines[mid].status != machine_not_used);
//
//  /* free machine's stack */
//  free(machines[mid].SP_begin);
//
//  /* set machine's status to 'not_used' */
//  machines[mid].status = machine_not_used;
//  used_machines--;
//
//}





/* link and relocate addresses */
void link_globals_and_relocate(U8* code, 
                               U32 size)     // size of code
{
  U8 *ptr = code;
  U32 k;

  //printf("link_globals: code size = %d\n",size); my_exit(1);

  assert((((U32)code)&3) == 0); /* code must be aligned on 0 mod 4 */

  while ( ((U32)(ptr-code)) < size)
  {
#if 0
    //if ((*ptr == i_word_64) || (*ptr == i_word_128) || (*ptr == i_load_int_big))
    {
      LOGINFO("relocating instr '%s' (%d) at offset %d\n",instr_names[*ptr],*ptr,ptr-code);
      fflush(stdout);
      //getchar(); 
    }
#endif

    switch (*ptr)
    {
      /* one byte instructions: nothing to relocate */
      case i_odd_align:
      case i_ret:
      case i_del_index_direct:
      case i_del_index_indirect:
      case i_invalid:
      case i_push:
      case i_remove_monitor:
      case i_unlock:
      case i_lock:
      case i_pop1:
      case i_pop3:
      case i_swap:
      case i_push_eq_data:
      case i_copy_ptr:
      case i_copy_function:
      case i_copy_int:
      case i_vcopy_ptr:
      case i_vcopy_function:
      case i_vcopy_int:
      case i_vcopy_null:
      case i_index_indirect:
      case i_free_seg_0:
      case i_free_seg_1_pop2_ret:
      case i_free_closure_1_pop2_ret:
      case i_indirect_del_ptr:
      case i_indirect_del_function:
      case i_indirect_del_multiclosure:
      case i_indirect_del_int:
      case i_del_function:
      case i_del_multiclosure:
      case i_del_int:
      case i_indirect_del_conn:
      case i_indirect_del_queue_in:
      case i_indirect_del_queue_out:
      case i_eq_string:
      case i_eq_byte_array:
      case i_eq_int:
      case i_give_up:
      case i_start_debug_avm:
      case i_stop_debug_avm:
      case i_read_locvar:
      case i_write_locvar:
      case i_new_locvar:
      case i_del_ptr:
      case i_del_conn:
      case i_finish:
        /* primitive types pseudo-instructions */
#define item(n) case i_##n:
        primitive_types_list
#undef item
#define item(n) case i_indirect_##n:
          primitive_types_list
#undef item
      case i_type_Opaque:
      case i_indirect_type_Opaque:
      case i_type_0:
      case i_indirect_type_0:
      case i_alt_number_indirect:
      case i_free_var_seg:
      case i_create_var:
      case i_get_vv:
      case i_xchg_vv:
      case i_ret_if_zero:
      case i_get_var_monitors:
      case i_nop:
      case i_execute_module:
      case i_lock_var: 
      case i_unlock_var:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s",ptr-code,instr_names[*ptr]);
          }
          ptr += 1;
          break;

          /* two bytes instructions: nothing to relocate */
      case i_glue_index:
      case i_glue:
      case i_store_index:
      case i_store_0:
      case i_store_1:
      case i_store_2:
      case i_store_4:
      case i_glue_mixed_index:
      case i_unstore_0:
      case i_unstore_1:
      case i_unstore_2:
      case i_unstore_4:
      case i_index_direct:
      case i_alt_number_direct:
      case i_alloc:
      case i_increment_del:
      case i_increment_eq:
      case i_copy_mixed:
      case i_vcopy_mixed:
      case i_unstore_copy_ptr:
      case i_unstore_copy_function:
      case i_unstore_copy_int:
      case i_copy_stack_ptr:
      case i_copy_stack_function:
      case i_copy_stack_int:
      case i_mixed_alt_begin:
      case i_large_alt_begin:
      case i_mixed_alt_end:
      case i_large_alt_end:
      case i_revert_to_computing:
      case i_success:
      case i_protect:
      case i_indirect_del_struct_ptr:
      case i_apply:
      case i_incr_indirect_del_ptr:
      case i_incr_indirect_del_function:
      case i_incr_indirect_del_conn:
      case i_incr_indirect_del_int:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d",ptr-code,instr_names[*ptr],*(ptr+1));
          }
          ptr += 2;
          break;

          /* three bytes instructions: nothing to relocate */
      case i_unglue:
      case i_unstore_copy_mixed:
      case i_copy_stack_mixed:
      case i_syscall:
      case i_put_copy_direct:
      case i_put_copy_indirect:
      case i_put_copy_function:
      case i_put_copy_int:
      case i_incr_indirect_del_struct_ptr:
      case i_sdrep:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d %d",ptr-code,instr_names[*ptr],*(ptr+1),*(ptr+2));
          }
          ptr += 3;
          break;

          /* five bytes instructions of the form (U8)instr (U32)address (address must be relocated) */
      case i_address:
      case i_call:
      case i_del:
      case i_false_jmp:
      case i_indirect_del:
      case i_jmp:
      case i_jmp_eq_stack:
      case i_jmp_false:
      case i_jmp_neq_0:
      case i_jmp_neq_1:
      case i_jmp_neq_2:
      case i_jmp_neq_4:
      case i_jmp_neq_indexes_large:
      case i_jmp_neq_string:
      case i_jmp_neq_byte_array:
      case i_jmp_neq_int:
      case i_true_jmp:
      case i_push_retpoint:
      case i_push_function:
      case i_type_large:
      case i_indirect_type_large:
      case i_serialize:
      case i_unserialize:
      case i_dec3:
      case i_unprotect:
      case i_get_var_handler:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %u",ptr-code,instr_names[*ptr],
                *((U32 *)(ptr+1)));
          }
          ptr++;
          RELLOC(ptr, code);
          break;

          /* six bytes instructions of the form (U8)instr (U32)address (U8) (address must be relocated) */
      case i_incr_indirect_del:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %u %d",ptr-code,instr_names[*ptr],
                *((U32 *)(ptr+1)),*(ptr+5));
          }
          ptr++;
          RELLOC(ptr,code);
          ptr++;
          break;

          /* seven bytes instructions of the form (U8)instr (U8)mask (U32)address (U8) (address must be relocated) */
      case i_incr_indirect_del_mixed:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d %u %d",ptr-code,instr_names[*ptr],
                *(ptr+1),*((U32 *)(ptr+2)),*(ptr+6));
          }
          ptr += 2;
          RELLOC(ptr,code);
          ptr++;
          break;

          /* four bytes instructions: no relocation */
      case i_put_copy_mixed:
      case i_put_micro_copy_direct:
      case i_put_micro_copy_indirect:
      case i_put_micro_copy_function:
      case i_put_micro_copy_int:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d %d %d",ptr-code,instr_names[*ptr],
                *(ptr+1),*(ptr+2),*(ptr+3));
          }
          ptr += 4;
          break;

          /* five bytes instructions without relocation */
      case i_put_micro_copy_mixed:
      case i_load_int_small:
      case i_load_int_small_push:
      case i_load_word32:
      case i_peek:
      case i_peek_push:
      case i_peek_copy_push_ptr:
      case i_peek_copy_push_function:
      case i_peek_copy_push_int:
      case i_peek_copy_ptr:
      case i_peek_copy_function:
      case i_peek_copy_int:
      case i_collapse:
      case i_eq:
      case i_del_stack_ptr:
      case i_del_stack_conn:
      case i_check_stack:
      case i_del_stack_function:
      case i_del_stack_multiclosure: 
      case i_del_stack_int:
      case i_del_stack_queue_in:
      case i_del_stack_queue_out:
      case i_syscall32:
      case i_push_word32:
      case i_push_ffcomp:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d %d %d %d",ptr-code,instr_names[*ptr],
                *(ptr+1),*(ptr+2),*(ptr+3),*(ptr+4));
          }
          ptr += 5;
          break;

          /* six bytes instructions without relocation */
      case i_peek_copy_push_mixed:
      case i_peek_copy_mixed:
      case i_del_stack_struct_ptr:
      case i_peek_ffcomp:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d %u",ptr-code,instr_names[*ptr],
                *(ptr+1),*((U32 *)(ptr+2)));
          }
          ptr += 6;
          break;
      case i_end_op:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %u %d", ptr-code, instr_names[*ptr],
                *((U32 *)(ptr+1)), *(ptr+5));
          }
          ptr += 6;
          break;
          


          /* six bytes instructions of the form (U8)instr (U8) (U32)address (address must be relocated)*/
      case i_select_index_indirect:
      case i_del_mixed:
      case i_indirect_del_mixed:
      case i_start:
      case i_startp:
      case i_type_mixed:
      case i_indirect_type_mixed:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d %u",ptr-code,instr_names[*ptr],
                *(ptr+1),*((U32 *)(ptr+2)));
          }
          ptr += 2;
          RELLOC(ptr, code);
          // *(((U32 *)ptr)++) += (U32)code;
          break;

          /* nine bytes instructions of the form (U8)instr (U32)address (U32)address (both addresses must be relocated)*/
      case i_put_closure_labels:
      case i_create_queue:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %u %u",ptr-code,instr_names[*ptr],
                *((U32 *)(ptr+1)),*((U32 *)(ptr+5)));
          }
          ptr += 1;
          RELLOC(ptr, code);
          // *(((U32 *)ptr)++) += (U32)code;
          RELLOC(ptr, code);
          // *(((U32 *)ptr)++) += (U32)code;
          break;

          /* seven bytes instructions of the form (U8)instr (U8) (U8) (U32) address (address must be relocated)*/
      case i_select_index_direct:
      case i_jmp_neq_indexes_mixed:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d %d %u",ptr-code,instr_names[*ptr],
                *(ptr+1),*(ptr+2),*((U32 *)(ptr+3)));
          }
          ptr += 3;
          RELLOC(ptr, code);
          // *(((U32 *)ptr)++) += (U32)code;
          break;

          /* nine bytes instructions of the form (U8)instr (U32)depth (U32)address (address must be relocated) */
      case i_del_stack:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %u %u",ptr-code,instr_names[*ptr],
                *((U32 *)(ptr+1)),*((U32 *)(ptr+5)));
          }
          ptr += 5;
          RELLOC(ptr, code);
          // *(((U32 *)ptr)++) += (U32)code;
          break;
          

          /* ten bytes instructions of the form (U8)instr (U32) (U8) (U32)address (address must be relocated) */
      case i_del_stack_mixed:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %u %d %u",ptr-code,instr_names[*ptr],
                *((U32 *)(ptr+1)),*(ptr+5),*((U32 *)(ptr+6)));
          }
          ptr += 6;
          RELLOC(ptr, code);
          // *(((U32 *)ptr)++) += (U32)code;
          break;

          /* nine bytes instructions without relocation */
      case i_load_float:
      case i_micro_peek:
      case i_micro_peek_push:
      case i_micro_peek_copy_ptr:
      case i_micro_peek_copy_push_ptr:
      case i_micro_peek_copy_function:
      case i_micro_peek_copy_push_function:
      case i_micro_peek_copy_int:
      case i_micro_peek_copy_push_int:
      case i_mcollapse:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %u %u",ptr-code,instr_names[*ptr],
                *((U32 *)(ptr+1)),*((U32 *)(ptr+5)));
          }
          ptr += 9;
          break;

          /* ten bytes instructions without relocation */
      case i_micro_peek_copy_mixed:
      case i_micro_peek_copy_push_mixed:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d, %u %u",ptr-code,instr_names[*ptr],
                *((U8 *)(ptr+1)),*((U32 *)(ptr+2)),*((U32 *)(ptr+6)));
          }
          ptr += 10;
          break;

          /* (U8)instr (U8)k (U32)address_1 ... (U32)address_k (all addresses must be relocated) */
      case i_switch:
      case i_type_large_switch:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d",ptr-code,instr_names[*ptr], *(ptr+1));
            for (k = 0; k < *(ptr+1); k++)
            {
              fprintf(nsc_file," %u",*((U32 *)(ptr+2+(k*4))));
            }
          }
          ptr++;
          k = *ptr;
          ptr++;
          for (; k >0; k--)
          {
            RELLOC(ptr,code);
          }
          break;

          /* (U8)instr (U8)k (U32)address_0 (U32)address_1 ... (U32)address_k (all addresses must be relocated) 
             the same one, but with one more address.
          */
      case i_put_multiclosure_labels:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d",ptr-code,instr_names[*ptr], *(ptr+1));
            for (k = 0; k < *(ptr+1); k++)
            {
              fprintf(nsc_file," %u",*((U32 *)(ptr+2+(k*4))));
            }
          }
          ptr++;
          k = (*ptr)+1;  // one more address
          ptr++;
          for (; k >0; k--)
          {
            RELLOC(ptr,code);
          }
          break;

          /* (U8)instr (U8)mask (U8)k (U32)address_1 ... (U32)address_k (all addresses must be relocated) */
      case i_type_mixed_switch:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d %d",ptr-code,instr_names[*ptr],
                *(ptr+1),*(ptr+2));
            for (k = 0; k < *(ptr+2); k++)
            {
              fprintf(nsc_file," %u",*((U32 *)(ptr+3+(k*4))));
            }
          }
          ptr++;
          ptr++;       /* mask for mixed type */
          k = *ptr;
          ptr++;
          for (; k > 0; k--)
          {
            RELLOC(ptr, code);
            // *(((U32 *)ptr)++) += (U32)code;
          }
          break;

      case i_mdrep:   /* mdrep U16 U16 (U16)n n*(U8,U16)  nothing to relocate  */ 
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d %d ",ptr-code,instr_names[*ptr],
                  *((U16 *)(ptr+1)),*((U16 *)(ptr+3)));
            for (k = 0; k < *((U16 *)(ptr+5)); k++)
            {
                fprintf(nsc_file,"(%d . %d) ",*((U8 *)(ptr+7+3*k)),*((U16
                    *)(ptr+8+3*k))); 
            }
          }
          ptr += 7+3*(*((U16 *)(ptr+5)));
          break;
          
          /* strings must be 'deciphered' (each byte XORed with 172) */
      case i_string:
      case i_string_push:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %u (\"",ptr-code,instr_names[*ptr],
                *((U32 *)(ptr+1)));
            for (k = 0; k < (U32)(*((U32 *)(ptr+1))); k++)
            {
              fprintf(nsc_file,"%c",(*(ptr+5+k))^172);
            }
            fprintf(nsc_file,"\")");
          }
          for (k = 0;  k < (U32)(*((U32 *)(ptr+1))); k++)
          {
            *(ptr+k+5) ^= 172;
          }
          ptr += 5+(U32)(*((U32 *)(ptr+1)));
          break;

      case i_byte_array:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %d ({",ptr-code,instr_names[*ptr],
                *((U32 *)(ptr+1)));
            for (k = 0; k < (*((U32 *)(ptr+1))); k++)
            {
              fprintf(nsc_file,"%d ",(*(ptr+5+k)));
            }
            fprintf(nsc_file,"})");
          }
          ptr += 5+(*((U32 *)(ptr+1)));
          break;

          /* (U8)instr (U8)dec [dec align bytes] (U32)counter
             (U32)numbigits (U32)bigit ... (U32)bigit
             [3-dec align bytes]
             total size: 1 + 1 +dec + 4 + 4 + 4*numbigits + (3-dec) = 13 + 4*numbigits
             (no relocation) */
      case i_load_int_big:
      case i_load_int_big_push:
          {
            U32 n = *((U32 *)(ptr+1));    /* number of bigits */ 
            ptr += 5 + 4*n; 
            if (nsc_file != NULL)
            {
              fprintf(nsc_file,"\n%8d |   %s  ",ptr-code,instr_names[*ptr]);
              fprintf(nsc_file,"(%u bigits) ",*((U32 *)(ptr+1)));
              for (k = 0; k < (U32)(*((U32 *)(ptr+1))); k++)
              {
                fprintf(nsc_file,"%d ",(*(ptr+5+k)));
              }
            }
          }
          break;

          /* (U8)instr (U32)k (U8)byte_1 ... (U8)byte_k (no relocation) */
      case i_type_small_alt:
      case i_type_8:
      case i_type_16:
      case i_type_32:
      case i_indirect_type_8:
      case i_indirect_type_16:
      case i_indirect_type_32:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s %u",ptr-code,instr_names[*ptr],
                *((U32 *)(ptr+1)));
            for (k = 0; k < (U32)(*((U32 *)(ptr+1))); k++)
            {
              fprintf(nsc_file,"%d ",*(ptr+5+k));
            }
          }
          ptr++;
          k = *(((U32 *)(ptr)));
          ptr += sizeof(U32);
          ptr += k;
          break;

          /* (U8)instr [25 bytes] (no relocation) */
      case i_begin_op:
          if (nsc_file != NULL)
          {
            fprintf(nsc_file,"\n%8d |   %s(%s)", ptr-code, instr_names[*ptr], ptr+4);
          }
          ptr += 26;
          break;

          /* (U8)instr [16 bytes] (no relocation) */
      case i_word_64:
      case i_word_64_push:
          {
            assert((((U32)ptr + 2 + (U32)(*(ptr+1))) & 3) == 0);
            if (nsc_file != NULL)
            {
              U32 dec = *(ptr+1);
              fprintf(nsc_file,"\n%8d |   %s %ux %ux ", ptr-code, instr_names[*ptr],
                  (U32)(ptr+6+dec), (U32)(ptr+10+dec));
            }
            ptr += 17;
          }
          break;

          /* (U8)instr [24 bytes] (no relocation) */
      case i_word_128:
      case i_word_128_push:
          {
            assert((((U32)ptr + 2 + (U32)(*(ptr+1)) ) & 3) == 0);
            if (nsc_file != NULL)
            {
              fprintf(nsc_file,"\n%8d |   %s %ux %ux %ux %ux ", ptr-code, instr_names[*ptr],
                  (U32)(ptr+5), (U32)(ptr+9), (U32)(ptr+13), (U32)(ptr+17));
            }
            ptr += 25;
          }
          break;

      default:
          LOGINFO("link_globals: unknown instruction: %d at %d\n",*ptr,ptr-code);
          fflush(stdout);
          my_exit(3);
          assert(0);
    }
  }
}



/* making a virtual machine pair */
U32 anubis_cons(U32 h, U32 t, U32 index, AnubisAllocator *allocator)
{
  U32 result;

  if ((result = allocator->AllocateDataSegment(3)) == 0)
  {
    allocator->EnlargeMemory();
    if ((result = allocator->AllocateDataSegment(3)) == 0)
    {
      printf("Cannot make a pair.\n");
      return 0;
    }
  }

  ((U32 *)result)[1] = h;
  ((U32 *)result)[2] = t;

  return result|index;   /* glue mixed index */
}


/* making a virtual machine triple */
U32 anubis_mcons3(U32 h, U32 t, U32 u, U32 index, AnubisAllocator *allocator)
{
  U32 result;

  if ((result = allocator->AllocateDataSegment(4)) == 0)
    return 0;

  ((U32 *)result)[1] = h;
  ((U32 *)result)[2] = t;
  ((U32 *)result)[3] = u;

  return result|index;   /* glue mixed index */
}


/*************** Connections tools ***************************/



/* opening a connection to a file */
  U32                                      /* returns 1 if connection opened, 0 otherwise */
open_file_connection(U32 data_seg,       /* segment, see vm.c and vm.h */
    char *name,         /* name of connection */
    U32 read_or_write,  /* 'conn_read' and friends ORed here */
    U32 mode)
{
  FILE *fp;
  char cmode[4];
  U32 i;
  struct stat statbuf;
  char new_name[1000];

  strcpy(cmode, (read_or_write==conn_read) ? "rb" : ((mode==0) ? "w+b" : "a+b"));
  snprintf(new_name,995,"%s",name);
  i = 0;
  while (new_name[i] != 0)
  {
#ifdef WIN32
    if (new_name[i] == '/') new_name[i] = '\\';
#else
    if (new_name[i] == '\\') new_name[i] = '/';
#endif
    i++;
  }

  if (read_or_write == conn_read)
  {
    if (stat(new_name,&statbuf)) return 0;
#ifdef WIN32
    if (! (_S_IFREG & statbuf.st_mode)) return 0;
#else
    if (! S_ISREG(statbuf.st_mode)) return 0;
#endif
  }

  //printf("Trying to open file %s ... ",new_name);
  if ((fp = fopen(new_name,cmode)) == NULL)
  {
    //printf("Failed.\n");
    return 0;
  }

  *(((U8 *)data_seg)+4) = (U8)conn_file;
  *(((U8 *)data_seg)+5) = (U8)mode;
  *((U32 *)(((U8 *)data_seg)+8)) = (U32)fp;
  //printf("Succeeded.\n");
  return 1;
}






/*** Network (IP) ***/



/* opening a connection to the network */
U32    /* returns:   0  success or still in progress
          1  cannot create the socket
          2  address:port not available on remote machine
          3  connection refused by server
          4  network unreachable
          5  address:port already in use
        */
open_IP_connection(U32 conn_seg,
    U32 ip_addr,
    U32 ip_port,
    U32 mode)
{
  U32 sockError = 0;
#ifdef WIN32
  U32 sock = 0;
#else
  int sock = 0;
#endif

#if defined (_LINUX_) || (__BEOS__)
  int oldflags;
#endif
  struct sockaddr_in server_name;

  /* create a socket */
  sock = socket(AF_INET, SOCK_STREAM,0);
#ifdef WIN32
  if (sock == INVALID_SOCKET)
  {
    fprintf(stderr, "[VM] Can't create socket. WSAGetLastError() = %d\n", WSAGetLastError());
#else
    if (sock < 0)
    {
      fprintf(stderr, "[VM] Can't create socket. errno = %d\n", errno);
#endif
      return 1;
    }

    //    struct linger the_linger;
    //    the_linger.l_onoff = 1;    /* transmit all before closing */
    //    the_linger.l_linger = 2;   /* timeout = 2 sec */
    //    setsockopt(sock, SOL_SOCKET,SO_LINGER,(char*)&the_linger,sizeof(struct linger));


    /* make the socket non blocking (this is required to
       make connect return immediately) */

#if defined (_LINUX_) || (__BEOS__)
    oldflags = fcntl(sock,F_GETFL,0);
    if (oldflags == -1)
    {
      shutdown(sock, 2);
      closesocket(sock);
      return 1;
    }
    oldflags |= O_NONBLOCK;
    fcntl(sock,F_SETFL,oldflags);
    bool keepAlive = true;
    setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char *) &keepAlive, sizeof(bool));
#endif
#ifdef WIN32
    {
      u_long argp = 1;
      ioctlsocket(sock,FIONBIO,&argp);
      bool keepAlive = true;
      setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char *) &keepAlive, sizeof(bool));
    }
#endif

    /* initialize server_name */
    memset(&server_name,0,sizeof(struct sockaddr_in));
    server_name.sin_family = AF_INET;
    server_name.sin_port = htons((U16)ip_port);
    memcpy(&server_name.sin_addr, &ip_addr, sizeof(U32));


    //  printf("Socket %d port %d\n",sock,ip_port);
    //printf("\ntry open %d.%d.%d.%d|%d socket %d ",server_name.sin_addr.S_un.S_un_b.s_b1,server_name.sin_addr.S_un.S_un_b.s_b2,server_name.sin_addr.S_un.S_un_b.s_b3,server_name.sin_addr.S_un.S_un_b.s_b4,ip_port,sock);
    /* try to connect */
    if (connect(sock,(struct sockaddr *)&server_name,sizeof(struct sockaddr)) == -1)
    {
#if WIN32
      sockError = GetLastError();
#else
      sockError = errno;
#endif

      switch (sockError)
      {
        case EINPROGRESS:
        case EWOULDBLOCK:
          //#ifdef WIN32
          //    case WSAEWOULDBLOCK:
          //#endif
          break;

        case EADDRNOTAVAIL:
          closesocket(sock);
          return 2;

        case ECONNREFUSED:
          closesocket(sock);
          return 3;

        case ENETUNREACH:
          closesocket(sock);
          return 4;

        case EADDRINUSE:
          closesocket(sock);
          return 5;

        default:
          closesocket(sock);
          return 1;
      }
    }

    /* at that point the connection is perhaps not established,
       but we can't wait. The connection is flagged 'in_progress'.
       This flag will be tested by another routine: is_IP_connection_ready. */

    *(((U8 *)conn_seg)+4) = (U8)conn_network;
    *(((U8 *)conn_seg)+5) = (U8)mode;
    *(((U32 *)conn_seg)+4) = (U32)(time(NULL)+3600);   /* timeout */
    *((U32 *)(((U8 *)conn_seg)+8)) = (U32)sock;
    return 0;
  }



  U32 /* returns:   0   ready
         1   not yet ready
         2   time is out
         3   connection failed
       */
    is_IP_connection_ready(U32 conn_seg)
    {
#define flags (((U8 *)conn_seg)[5])
#define count (((U32 *)conn_seg)[4])
      U32 optVal;
      U32 optLen = sizeof(U32);


      U32 sock = *(U32 *)(((U8 *)conn_seg)+8);

      //  FD_ZERO(&the_fd_set);
      //
      FD_SET(sock,&the_fd_set);

      FD_ZERO(&the_fd_read_set);
      FD_ZERO(&the_fd_write_set);
      FD_ZERO(&the_fd_except_set);
      FD_SET(sock, &the_fd_write_set);
      FD_SET(sock, &the_fd_read_set);
      FD_SET(sock, &the_fd_except_set);
      //printf(".");

      timeout_no_wait.tv_sec = 0;
      timeout_no_wait.tv_usec = 0;

      if (select(FD_SETSIZE,
            &the_fd_read_set,
            &the_fd_write_set,
            &the_fd_except_set,
            &timeout_no_wait) <= 0)
      {
        /* not yet ready */
        if (count < (U32)time(NULL))
        {
          //printf("\ntime is out\n"); fflush(stdout);
          shutdown(sock,2);
          closesocket(sock);
          return 2;
        }
        else
        {
          return 1;
        }
      }
      else
      {
        if (FD_ISSET(sock, &the_fd_write_set))
        {
          //      printf("Socket write status\n");
          if(getsockopt(sock, SOL_SOCKET, SO_ERROR, (char*)&optVal, (socklen_t*)&optLen) != SOCKET_ERROR)
          {
            switch(optVal)
            {
              case ECONNREFUSED:
                //              printf("socket %d connection refused\n", sock);
                shutdown(sock,2);
                closesocket(sock);
                return 3;

              case 0:
                //              printf("socket connection ok\n");
                return 0;

              default:;
                      //              printf("socket %d error value [%d] ", sock, optVal);
            }
          }
          //      printf("SockOpt Value: %ld\n", optVal);
          shutdown(sock,2);
          closesocket(sock);
          return 3;
        }

        if(FD_ISSET(sock, &the_fd_except_set))
        {
          //      printf("Socket exception status\n");
          if(getsockopt(sock, SOL_SOCKET, SO_ERROR, (char*)&optVal, (socklen_t*)&optLen) != SOCKET_ERROR)
          {
            switch(optVal)
            {
              case ECONNREFUSED:
                //              printf("socket %d connection refused ", sock);
                break;
              default:;
                      //              printf("socket %d error value [%d] ", sock, optVal);
            }
          }
          //      printf("SockOpt Value: %ld\n", optVal);
          //      printf("is_IP_connection_ready Socket [%d] exception\n", sock);
          shutdown(sock,2);
          closesocket(sock);
          return 3;
        }
        /* connection is ready */
        return 0;
      }

#undef flags
#undef count
    }


  /**
   * Return true if the connection is closed. Else the operation would block,
   * then it should be tried again later.
   */

  bool close_connection(U8 *conn)
  {
#ifdef WIN32
  SOCKET fdSocket = ~0;
#else
  SOCKET fdSocket = -1;
#endif

    bigtime_t t0 = 0;

    switch (conn[4])   /* type of connection */
    {
      case conn_file:
        {
          FILE *fp =  (FILE *)(*((U32 *)(((U8 *)conn)+8)));

          if (fp != stdin && fp != stdout && fp != stderr)
          {
            int err = errno;
            if(fclose(fp) != 0)
              LOGERROR("close_connection: close on file(%d) failed with errno = %d.\n", fileno(fp), err);
          }
          return true;
        }

      case conn_network:
        fdSocket = (*((int *)(conn+8)));
        //      LOGINFO("NETWORK SOCKET [%d] CLOSE REQUESTED\n",fdSocket);

FD_CLR(fdSocket, &descriptors_waited_for_input);
FD_CLR(fdSocket, &descriptors_waited_for_output);

        t0 = system_time();
        {
          fd_set rfds, wfds, efds;
          FD_ZERO(&rfds);
          FD_SET(fdSocket,&rfds);
          FD_ZERO(&wfds);
          FD_SET(fdSocket,&wfds);
          FD_ZERO(&efds);
          FD_SET(fdSocket,&efds);
          timeout_no_wait.tv_sec = 0;
          timeout_no_wait.tv_usec = 0;
          int nb = select(FD_SETSIZE, &rfds, &wfds, &efds, &timeout_no_wait);
          if(nb < 0)
          {
            LOGERROR("close_connection: select() failed with errno = %d.\n", LAST_SOCKET_ERROR);
          }
          else if(nb == 0) // Some data needs to be sent. Closing the socket will lose these data.
          {
            //LOGINFO("All data not yet sent, delaying the socket (%d) close.\n", fdSocket);
            return false;
          }
          else if(FD_ISSET(fdSocket, &efds))
          {
            LOGERROR("close_connection: socket (%d) was in error state.\n", fdSocket);
          }
          else if(! FD_ISSET(fdSocket, &wfds))
          {
            if(FD_ISSET(fdSocket, &rfds))
            {
              char buf[10];
              int nb = recv(fdSocket, buf, 1, 0);
              if(nb < 0)
                LOGERROR("close_connection: Socket (%d) is ready for read, but reading it returns an error [%d].\n", fdSocket, LAST_SOCKET_ERROR);
              //             else if(nb == 0)
              //               LOGINFO("Socket (%d) was gracefully closed by client.\n", fdSocket);
              //             else
              //               LOGINFO("close_connection: Socket (%d) ready for reading with data available.\n", fdSocket);
            }
            else
              LOGINFO("close_connection: Socket (%d) isn't in Ready state (read or write), nor in error state, but select() returns a positive value.\n", fdSocket);
          }


          // our socket is ready for writing, so all data are sent. We can close it.
        }

        if(shutdown(fdSocket, 2) == SOCKET_ERROR)
        {
          int err = LAST_SOCKET_ERROR;
          if(err != ENOTCONN)
            LOGERROR("close_connection: shutdown failed with errno = %d.\n", err);
        }

      case conn_listener:
        if is_invalid_socket(fdSocket)
        {
          fdSocket = (*((int *)(conn+8)));
          t0 = system_time();  // case of listener
        }

        if(closesocket(fdSocket) == SOCKET_ERROR)
        {
          int err = LAST_SOCKET_ERROR;
          //LOGERROR("close_connection: close on socket(%d) failed with errno = %d.\n", fdSocket, err);
          if(err == EWOULDBLOCK) // Only under Windows, but should never occur because of the previous select()
            return false;
        }
        t0 = system_time() - t0;
        if(t0 > 1000000)
        {
          printf("close_connection() too long (%.1f s)\n", (float)t0 / 1000000.0);
        }
        return true;

      case conn_local:
        return true;

      default:
        assert(0);
        return true;
    }
  }


  /* This function is never called (remarked 2006/07/11) */
  U32 connection_is_closed(U32 c)
  {
    U8 *conn = (U8 *)c;

    switch (conn[4])
    {
      case conn_file:
        return 0;

      case conn_listener:
        return 0;

      case conn_network:
        //      close(*((int *)(conn+8)));
        return 0;

      case conn_local:
        return 0;

      default:
        assert(0);
        return 0;
    }
  }




  int   /* returns EOF (connection closed by peer) or a
           byte value or 2*EOF meaning 'wait' (connection still alive
           but nothing to be read from it) */
    read_byte(U8 *conn)
    {
      U8 str[2];
      int i;

      switch (conn[4])     /* type of connection (see vm.h) */
      {
        case conn_file:
          FILE* fd;
      fd = *((FILE **)(conn+8));
      if (0 && fd == stdin)  // inhibited because kbhit/getch do not work (try with syntactic_analysis/calculator_example.apg)
      {
#ifdef WIN32
/*            HANDLE handle = GetStdHandle(STD_INPUT_HANDLE);
            DWORD events;
            INPUT_RECORD buffer;
      PeekConsoleInput(handle, &buffer, 1, &events);
      if (events > 0)
      {
        if(buffer.EventType == KEY_EVENT & buffer.Event.KeyEvent.bKeyDown==1)
        {
          int read_char;
          ReadConsoleInput(handle, &buffer, 1, &events);
        
          read_char = buffer.Event.KeyEvent.uChar.AsciiChar;
          FlushConsoleInputBuffer(handle);
          if (read_char == 0)
          {
            return 2*EOF;
            }
          else
          {
            if (read_char != 27) //don't show escape
              putchar(read_char);
              
            //printf("Read char [%d]\n bKeyDown [%d]\n",read_char, buffer.Event.KeyEvent.bKeyDown);
            return(read_char);
          }
        }
        else if (buffer.EventType > 0)
        {
          FlushConsoleInputBuffer(handle);
        }
      }
      return 2*EOF; 
*/
#endif
      if (kbhit())  //a character waiting to be read
        return(getch());
      else
        return 2*EOF;

      }
          return getc(fd);

        case conn_network:
          {
            int sock = *(int *)(conn+8);

            //fprintf(stderr,"Trying to read a byte         \n"); fflush(stderr);

            FD_CLR(sock, &descriptors_waited_for_input);
            /* read a byte from the connection */
            i = recv(sock,(char *)str,1,0);
#if defined (_LINUX_) || (__BEOS__)
            if (i == -1 && errno == EWOULDBLOCK)
            {
              //fprintf(stderr,"i = %d errno = EWOULDBLOCK         \r",i); fflush(stderr);
              printf("[READ_BYTE] sock=%d -> EWOULDBLOCK, re-register\n", sock);
              FD_SET(sock,&descriptors_waited_for_input);
              return 2*EOF;
            }
#endif
#ifdef WIN32
            if (i == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
            {
              printf("[READ_BYTE] sock=%d -> EWOULDBLOCK, re-register\n", sock);
              FD_SET(sock,&descriptors_waited_for_input);
              return 2*EOF;
            }
#endif
            else if (i > 0)
            {
              printf("[READ_BYTE] sock=%d -> byte=%d\n", sock, (int)str[0]);
              return str[0];
            }
            else
            {
              //printf("Connection closed by peer.\n");
              return EOF;   /* connection has been closed by peer */
            }
          }

        case conn_local:
          return (int)(conn[8]);

        default:
          assert(0);
          return EOF;
      }
    }



  int   /* returns a datum of type Maybe(One):
           0 = failure,
           1 = success(unique). */
    write_byte(U8 value, U8 *conn)
    {
      U8 str[2];
      str[0] = value;
      str[1] = 0;
#ifdef WIN32
      int flags = 0;
#else
      int flags = 0;
#ifndef __APPLE__
      flags = MSG_NOSIGNAL;
#endif
#endif

      switch (conn[4])   /* connection type */
      {
        case conn_file:
          if (putc(value,*((FILE **)(conn+8))) == EOF)
            return 0;
          else
            return 1;

        case conn_network:
          if (send(*(int *)(conn+8),(const char *)str,1,flags) != 1)
            return 0;
          else
            return 1;

        case conn_local:
          conn[8] = value;
          return 1;

        default:
          assert(0);
          return 0;
      }
    }



#ifdef WIN32
  int winsock_dll_found = 0;
#endif



  int create_listener_socket(int *socket_handle_addr)
  {
#ifdef WIN32
    if (!winsock_dll_found)
    {
      WSADATA wsadata;
      if (WSAStartup(MAKEWORD(2,2),&wsadata) != 0)
      {
        return 0;
      }
      winsock_dll_found = 1;
    }
#endif

    *socket_handle_addr = socket(PF_INET,SOCK_STREAM,0);
#ifdef WIN32
    if (*socket_handle_addr == (int)INVALID_SOCKET)
    {
      fprintf(stderr, "[VM] Can't create socket. WSAGetLastError() = %d\n", WSAGetLastError());
#else
      if (*socket_handle_addr < 0)
      {
        fprintf(stderr, "[VM] Can't create socket. errno = %d\n", errno);
#endif
        return 0;
      }
      else
      {
#if defined (_LINUX_) || (__BEOS__)
        int oldflags;
        oldflags = fcntl(*socket_handle_addr,F_GETFL,0);
        if (oldflags == -1)
        {
          shutdown(*socket_handle_addr,2);
          closesocket(*socket_handle_addr);
          return 0;
        }
        oldflags |= O_NONBLOCK;
        fcntl(*socket_handle_addr,F_SETFL,oldflags);
        fcntl(*socket_handle_addr,F_SETFD,FD_CLOEXEC);  /* needed by the 'must_restart' mecanism */
#endif
#ifdef WIN32
        u_long argp = 1;
        ioctlsocket(*socket_handle_addr,FIONBIO,&argp);
#endif
        return 1;
      }
    }



    int bind_socket_to_port(int socket_handle, U32 ip_addr, U32 ip_port)
    {
      struct sockaddr_in ip_name;
      memset(&ip_name,0,sizeof(struct sockaddr_in));
      ip_name.sin_family = AF_INET;
      memcpy(&ip_name.sin_addr,&ip_addr,sizeof(long));
      ip_name.sin_port = htons((unsigned short)ip_port);
#ifdef WIN32
      bool reuse = true;
      //setsockopt(socket_handle, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(bool));
      if(setsockopt(socket_handle, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(bool)))
#else
        int one = 1;
      if(setsockopt(socket_handle, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
#endif
      {
        LOGERROR("Bind socket SO_REUSEADDR error");
      }
      if (bind(socket_handle,(struct sockaddr *)&ip_name,sizeof(struct sockaddr_in)) < 0)
        return 0;
      else
        return 1;
    }



    int begin_to_listen(int socket_handle)
    {
      if (listen(socket_handle,5) < 0)
        return 0;
      else
        return 1;
    }



    void serialize_float(double d, U8 *dest)
    {
      *((double *)dest) = d;
    }


#define test_dns


    U32 call_dns(U32 host_name,U32 seg)
    {
      struct hostent *r;

      //printf("host_name = %d\n",host_name); fflush(stdout);
      //printf("(1) seg = %d\n",seg); fflush(stdout);
      //printf("calling 'gethostbyname(%s)'\n",((char *)host_name)+4); fflush(stdout);
      r = gethostbyname(((char *)host_name)+4);    /* avoid counter */

      //printf("(2) seg = %d\n",seg); fflush(stdout);
      //printf("'gethostbyname' returned r = %p\n",r); fflush(stdout);
      if (r == NULL)
      {
        //printf("r = 0\n"); fflush(stdout);
        switch (h_errno)
        {
          case HOST_NOT_FOUND:   ((U8 *)seg)[4] = 0;  return seg;    /* alt 0 of DNS_Result */
          case NO_ADDRESS:       ((U8 *)seg)[4] = 1;  return seg;
          case TRY_AGAIN:        ((U8 *)seg)[4] = 2;  return seg;
          default:               ((U8 *)seg)[4] = 3;  return seg;
        }
      }
      else
      {
        //printf("r != 0\n"); fflush(stdout);
        //printf("(3) seg = %d\n",seg); fflush(stdout);
        //printf("r->h_length = %d\n",r->h_length); fflush(stdout);
        //printf("(4) seg = %d\n",seg); fflush(stdout);
        if (r->h_length != 4)  { printf("dns: IP address is not IPv4.\n");   return 3; }
        ((U8 *)seg)[4] = 4;
        //printf("(5) seg = %d\n",seg); fflush(stdout);
        *((U32 *)(((U8 *)seg)+4+1)) = *((U32 *)(r->h_addr));
        //printf("(6) seg = %d\n",seg); fflush(stdout);
        return seg;
      }
    }


#define wtfdebug(s)
//#define wtfdebug(s) printf("%s\n",s); fflush(stdout);  

    int write_to_file(U32    conn,   // the connection or file
                      U8    *text,   // pointer to bytes to write
                      U32    n)      // maximal number of bytes to write
      /*
         returns either the number of bytes writen or
         -1 if cannot write (disk file and TCP)
         -2 if must wait (TCP only)
       */
    {
      wtfdebug("entering 'write_to_file'")

      switch (((U8 *)conn)[4])  /* connection type */
      {
        case conn_file:
          {
            wtfdebug("case conn_file")
            int r;
            
#ifdef WIN32 
            r = _write(fileno(*((FILE **)(((U8 *)conn)+8))),     /* file descriptor */
                      text,                         /* address of first byte */
                      n);                            /* number of bytes to write */
#else
            r = write(fileno(*((FILE **)(((U8 *)conn)+8))),     /* file descriptor */
                      text,                         /* address of first byte */
                      n);                            /* number of bytes to write */
#endif
            fflush(*((FILE **)(((U8 *)conn)+8))); 
            if (r < 0) 
            {
              wtfdebug("exiting 'write_to_file' (1)")
                return -1;
            }
            else 
            {
              wtfdebug("exiting 'write_to_file' (2)")
                return r;
            }
          }
          break;

        case conn_network:
          {
            wtfdebug("case conn_network (b)")
            int sock = *((U32 *)(((U8 *)conn)+8));
            wtfdebug("case conn_network (c)")
            int r = 0;
#ifdef WIN32
            int flags = 0;
#else
            int flags = 0;
#ifndef __APPLE__
            flags = MSG_NOSIGNAL;
#endif
#endif
            //FD_CLR((unsigned int)sock,&descriptors_waited_for_output);

            wtfdebug("calling 'send'")
            r = send(sock,          /* file descriptor */
                     (char*)text,          /* address of first byte */
                     n,             /* number of bytes to write */
                     flags);    
            wtfdebug("returning from 'send'")

#ifdef WIN32
            if (r == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
            {
              FD_SET((unsigned int)sock,&descriptors_waited_for_output);
              wtfdebug("exiting 'write_to_file' (3)")
              return -2;
            }
#endif
#if defined (_LINUX_) || (__BEOS__)
            if (r == -1 && (errno == EWOULDBLOCK || errno == EINTR))
            {
              FD_SET((unsigned int)sock,&descriptors_waited_for_output);
              wtfdebug("exiting 'write_to_file' (4)")
              return -2;
            }
#endif
            else if (r >= 0)
            {
              wtfdebug("exiting 'write_to_file' (5)")
              return r;
            }
            else
            {
              wtfdebug("exiting 'write_to_file' (6)")
                return -1;
            }
          }
          break;

        default: 
              wtfdebug("exiting 'write_to_file' (7)")
            return -1;
      }
    }



    int read_from_file(U32 conn, int n, U32 ba)
      /*
         returns either the number of bytes read, or
         -1 if cannot read (TCP/SSL = connection broken)
         -2 if must wait (TCP/SSL)
       */
    {
#define c   ((U8 *)conn)
#define a   ((U8 *)ba)

      if (n <= 0) return 0;

      switch (c[4])
      {
        case conn_file:
          {
            int i = 0;
            FILE *fp = (*((FILE **)(c+8)));

            i = fread(a+4+4,1, n, fp);

            //         if(i < n)
            //           {
            //             if (feof(fp))
            //               //printf("EOF reached\n");
            //             else if (ferror(fp))
            //               printf("errno %d\n",errno);
            //           }

            return i;
          }
          break;

        case conn_network:
          {
            int i;
            int sock = *(int*)(c+8);

            FD_CLR(sock,&descriptors_waited_for_input);

            /* read n bytes from the connection */
            i = recv(sock, (char *)a+4+4,n,0);

#ifdef WIN32
            if (i == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
            {
              //FD_SET(sock,&descriptors_waited_for_input);
              return -2;
            }
#endif
#if defined (_LINUX_) || (__BEOS__)
            //printf("i = %d n = %d\n",i,n); fflush(stdout);
            if (i == -1 && errno == EWOULDBLOCK)
            {
              //FD_SET(sock,&descriptors_waited_for_input);
              //printf(" wait\n"); fflush(stdout);
              return -2;
            }
#endif
            else if (i > 0)
            {
              assert(i <= n);
              //if (mf_using_ssl) store_random(a+4+4,i);
              return i;
            }
            else
            {
              return -1;
            }
          }
          break;


        default:
          return 0;
      }
#undef c
#undef a
    }
    
    
    int read_from_file_or_tcp(U32 conn, int n, U8 *dest)
      /*
         returns either the number of bytes read, or
         -1 if cannot read (connection closed)
         -2 if must wait (TCP)
         -3 end of file (end of file)
       */
    {
#define c   ((U8 *)conn)
#define a   ((U8 *)dest)

      if (n <= 0) return 0;

      switch (c[4])
      {
        case conn_file:
          {
            int i = 0;
            FILE *fp = (*((FILE **)(c+8)));

            i = fread(a,1, n, fp);

            if (i <= 0)
            {
                if (feof(fp))
                    return -3;
                else 
                    return 0; 
            }
            else 
              return i;
          }
          break;

        case conn_network:
          {
            int i;
            int sock = *(int*)(c+8);

            FD_CLR(sock,&descriptors_waited_for_input);

            /* read n bytes from the connection */
            i = recv(sock, (char *)a,n,0);

#ifdef WIN32
            if (i == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
            {
              FD_SET(sock,&descriptors_waited_for_input);
              return -2;
            }
#endif
#if defined (_LINUX_) || (__BEOS__)
            //printf("i = %d n = %d\n",i,n); fflush(stdout);
            if (i == -1 && errno == EWOULDBLOCK)
            {

       FD_SET(sock, &descriptors_waited_for_input);
              //printf(" wait\n"); fflush(stdout);
              return -2;
            }
#endif
            else if (i > 0)
            {
              assert(i <= n);
              return i;
            }
            else
            {
              return -1;
            }
          }
          break;


        default:
          return 0;
      }
#undef c
#undef a
    }

    
    

    int read_line_from_file(U32 conn, int n, U32 string, int *pos)
      /*
         returns either the line length, or
         -1 if cannot read (TCP/SSL = connection broken)
         -2 if must wait (TCP/SSL)
         -3 if EOF is reached
       */
    {
#define c   ((U8 *)conn)
#define a   ((U8 *)string)

      if (n <= 0) return 0;

      switch (c[4])
      {
        case conn_file:
          {
            //int i = *pos;
            FILE *fp = (*((FILE **)(c+8)));

            if(fgets((char*)a+4, n, fp))
            {
              char * p = (char*)a+4;
              size_t len = strlen(p);
              //           while(len > 0 && (p[len -1] == '\n' || p[len -1] == '\r'))
              //           {
              //             len--;
              //             p[len] = '\0';
              //           }
              return len;
            }
            else if(feof(fp))
            {
              *((char *)a+4) = '\0';
              return -3;
            }
            else
              return -1;
          }
          break;

        case conn_network:
          {
            int ret = 0;
            int sock = *(int*)(c+8);
            int i = *pos;
            char* buf = (char *)a+4;
            char ch = '\0';

            FD_CLR(sock,&descriptors_waited_for_input);

            /* read n bytes from the connection */
            while(i < n)
            {
              ret = recv(sock, &ch, 1, 0);

#ifdef WIN32
              if (ret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
#endif
#if defined (_LINUX_) || (__BEOS__)
                if (ret == -1 && errno == EWOULDBLOCK)
#endif
                {
                  FD_SET(sock, &descriptors_waited_for_input);
                  *pos = i;
                  return -2;
                }
                else if (ret > 0)
                {
                  assert(ret == 1);
                  *(buf + i) = ch;
                  i++;
                  if(ch == '\n')
                    break;
                }
                else
                {
                  return -1;
                }
            }
            *(buf + i) = '\0';
            return i;
          }
          break;


        default:
          return 0;
      }
#undef c
#undef a
    }


    U32 compute_file_size(U32 conn, AnubisAllocator *allocator)
    {
#define c  ((U8 *)conn)
      int result;

      switch (c[4])
      {
        case conn_file:
          {
            FILE *fp;
            //long int pos;
            struct stat st;
            fp = *((FILE **)(c+8));
      
            result =  fstat(fileno(fp),&st);

            if (result == 0)
            {
              return C_int64_to_Anubis_Int(st.st_size, allocator);
            }
            else
            {
              return 0;
            }

          }
          break;

        default: return 0;
      }
#undef c
    }


//    U32 compute_file_size(U32 conn, AnubisAllocator *allocator)
//    {
//#define c  ((U8 *)conn)
//      int result;
//
//      switch (c[4])
//      {
//        case conn_file:
//          {
//            FILE *fp;
//            //long int pos;
//            struct stat st;
//            fp = *((FILE **)(c+8));
//
//#ifdef WIN32
//            int64 size = _filelengthi64(fileno(fp));
//            return C_int64_to_Anubis_Int(size, allocator); //(U32)size;
//#else
//            result =  fstat(fileno(fp),&st);
//#endif
//            if (result == 0)
//            {
//              return (U32)(st.st_size);
//            }
//            else
//            {
//              return 0;
//            }
//
//#if 0
//            pos = ftell(fp);           /* remember current position */
//            fseek(fp,0,SEEK_END);      /* go to end of file */
//            result = (U32)ftell(fp);   /* get position, i.e. size of file */
//            rewind(fp);
//            fseek(fp,pos,SEEK_SET);    /* return to initial position */
//            return result;
//#endif
//
//          }
//          break;
//
//        default: return 0;
//      }
//#undef c
//    }

    /* convert an Unix file mode into an Anubis file mode (see predef.anubis)

       taken from predef.anubis:

       public type ReadMode:
       non_readable,             // -
       readable.                 // r

       public type WriteMode:
       non_writable,             // -
       writable.                 // w

       public type ExecMode:
       non_executable,           // -
       executable.               // x

       public type PrivilegedExecMode:
       non_executable,           // -
       executable,               // x
       may_change_id_no_exec,    // S     undocumented (?) Unix: means suid (guid) bit set but not executable
       may_change_id,            // s

       public type FileMode:                          // corresponding UNIX permission
       file(ReadMode user_readable,                 // r--------
       WriteMode user_writable,                // -w-------
       PrivilegedExecMode user_executable,     // --x------   --s------    --S------
       ReadMode group_readable,                // ---r-----
       WriteMode group_writable,               // ----w----
       PrivilegedExecMode group_executable,    // -----x---   -----s---    -----S---
       ReadMode others_readable,               // ------r--
       WriteMode others_writable,              // -------w-
       ExecMode others_executable).            // --------x

       public type SearchMode:
       non_searchable,
       searchable.

       public type DirectoryMode:
       directory(ReadMode user_readable,
       WriteMode user_writable,
       SearchMode user_searchable,
       ReadMode group_readable,
       WriteMode group_writable,
       SearchMode group_searchable,
       ReadMode others_readable,
       WriteMode others_writable,
       SearchMode others_searchable).

     */

    /* no need in WIN32 since we compile under mingw
#define S_IRUSR _S_IREAD
#define S_IWUSR _S_IWRITE
#define S_IXUSR _S_IEXEC
     */

#if defined (WIN32)
#define S_ISUID 0

//#define S_IRGRP _S_IREAD
//#define S_IWGRP 0
//#define S_IXGRP 0
#define S_ISGID 0

//#define S_IROTH _S_IREAD
//#define S_IWOTH 0
//#define S_IXOTH 0
#endif

    U16 make_file_mode(mode_t unix_mode)
    {
      U16 result = 0;

      if (unix_mode&S_IRUSR) result |= (1<<0);
      if (unix_mode&S_IWUSR) result |= (1<<1);
      if (unix_mode&S_IXUSR) result |= (1<<2);
      if (unix_mode&S_ISUID) result |= (1<<3);

      if (unix_mode&S_IRGRP) result |= (1<<4);
      if (unix_mode&S_IWGRP) result |= (1<<5);
      if (unix_mode&S_IXGRP) result |= (1<<6);
      if (unix_mode&S_ISGID) result |= (1<<7);

      if (unix_mode&S_IROTH) result |= (1<<8);
      if (unix_mode&S_IWOTH) result |= (1<<9);
      if (unix_mode&S_IXOTH) result |= (1<<10);

      return result;
    }

    U16 make_dir_mode(mode_t unix_mode)
    {
      U16 result = 0;

      if (unix_mode&S_IRUSR) result |= (1<<0);
      if (unix_mode&S_IWUSR) result |= (1<<1);
      if (unix_mode&S_IXUSR) result |= (1<<2);

      if (unix_mode&S_IRGRP) result |= (1<<3);
      if (unix_mode&S_IWGRP) result |= (1<<4);
      if (unix_mode&S_IXGRP) result |= (1<<5);

      if (unix_mode&S_IROTH) result |= (1<<6);
      if (unix_mode&S_IWOTH) result |= (1<<7);
      if (unix_mode&S_IXOTH) result |= (1<<8);

      return result;
    }



    /* transforming an ANUBIS directory mode into an UNIX mode */
#if defined (_LINUX_) || (__BEOS__)
    U32 anubis_directory_mode_to_UNIX(U32 amode)
    {
      U32 result = 0;

      if (amode&1)   result |= S_IRUSR;       /* 1 = user readable */
      if (amode&2)   result |= S_IWUSR;       /* 1 = user writable */
      if (amode&4)   result |= S_IXUSR;       /* 1 = user searchable */
      if (amode&8)   result |= S_IRGRP;       /* 1 = group readable */
      if (amode&16)  result |= S_IWGRP;       /* 1 = group writable */
      if (amode&32)  result |= S_IXGRP;       /* 1 = group searchable */
      if (amode&64)  result |= S_IROTH;       /* 1 = others readable */
      if (amode&128) result |= S_IWOTH;       /* 1 = others writable */
      if (amode&256) result |= S_IXOTH;       /* 1 = others searchable */
      return result;
    }
#endif


    U32 /* returns a result of type 'MakeDirectoryResult' (see predef.anubis):

           permission_denied         0
           name_already_exists       1
           too_many_links            2
           not_enough_room           3
           read_only_file_system     4
           ok                        5

         */
      make_directory(char *path, U32 amode)
      {
#if defined (_LINUX_) || (__BEOS__)
        if (mkdir(path,anubis_directory_mode_to_UNIX(amode)))
          switch(errno)
          {
            case EEXIST:  return 1;
            case EMLINK:  return 2;
            case ENOSPC:  return 3;
            case EROFS:   return 4;
            default:     return 0;
          }
        else
          return 5;
#endif
#ifdef WIN32
        if (mkdir(path))
          switch(errno)
          {
            case EEXIST:  return 1;
            default:     return 0;
          }
        else
          return 5;
#endif
      }

    // #if defined (_LINUX_) || (__BEOS__)
    U32 /* returns a result of type 'RemoveDirectoryResult' (see predef.anubis):

           directory_does_not_exist     0
           permission_denied            1
           read_only_file_system        2
           directory_not_empty          3
           ok                           4

         */
      remove_directory(char *path)
      {
        if (rmdir(path))
          switch(errno)
          {
            case EPERM:     return 1;
            case EROFS:     return 2;
            case ENOTEMPTY: return 3;
            default:        return 0;
          }
        else return 4;   /* ok */
      }
    // #endif
    // #ifdef WIN32
    // U32 remove_directory(char *path)
    // {
    //   if (rmdir(path))
    //   {
    //
    //   }
    //   return 1;
    // }
    // #endif