fix: windows compile warnings (#257)

* fix: misc debug warnings

* fix: warnings in call_out code

* fix: disassemble warnings

* fix: ed warnings

* fix: linux warnings

* fix: remove obsoleted inet_ntoa

* fix: socket efun warnings

Author: taedlar

docs/applies/master/valid_socket.md

@@ -11,8 +11,19 @@ int valid_socket (object caller, string function, mixed *info);
 Each of the socket efuns calls `valid_socket()` prior to executing.
 If `valid_socket()` returns 0, then the socket efun fails.
 If `valid_socket()` returns 1, then the socket efun attempts to succeed.
+
 The first argument **caller** is the object that called the socket efun.
-The second argument is the name of the socket efun that is being called (e.g. `socket_write()` or `socket_bind()`).
+The second argument is the name of the socket function that being called, which is one of below:
+- `"create"` when [socket_create()](../../efuns/socket_create.md) is called.
+- `"bind"` when [socket_bind()](../../efuns/socket_bind.md) is called.
+- `"listen"` when [socket_listen()](../../efuns/socket_listen.md) is called.
+- `"accept"` when [socket_accept()](../../efuns/socket_accept.md) is called.
+- `"connect"` when [socket_connect()](../../efuns/socket_connect.md) is called.
+- `"write"` when [socket_write()](../../efuns/socket_write.md) is called.
+- `"close"` when [socket_close()](../../efuns/socket_close.md) is called.
+- `"release"` when [socket_release()](../../efuns/socket_release.md) is called.
+- `"acquire"` when [socket_acquire()](../../efuns/socket_acquire.md) is called.
+
 The third argument is an array of information.
 The first element of the array (when applicable) is file descriptor being referenced.
 The second element of the array is the owner of the socket (object).

docs/efuns/socket_create.md

@@ -5,40 +5,41 @@
 ## SYNOPSIS
 ~~~cxx
 #include <socket_err.h>
-~~~
 
-int socket_create( int mode, string read_callback,
-void | string close_callback );
+int socket_create (int mode, string read_callback, void | string close_callback);
+~~~
 
 ## DESCRIPTION
 socket_create() creates an efun socket. mode determines
 which type of socket is created. Currently supported socket
 modes are:
 
-MUD         for sending LPC data types using TCP protocol.
-
-STREAM      for sending raw data using TCP protocol.
-
-DATAGRAM    for using UDP protocol.
+- `MUD` for sending LPC data types using TCP protocol.
+- `STREAM` for sending raw data using TCP protocol.
+- `DATAGRAM` for using UDP protocol.
 
-The argument read_callback is the name of a function for the
+The argument `read_callback` is the name of a function for the
 driver to call when the socket gets data from its peer. The
 read callback should follow this format:
 
+~~~cxx
 void read_callback(int fd, mixed message)
+~~~
 
-Where fd is the socket which received the data, and message
+Where `fd` is the socket which received the data, and `message`
 is the data which was received.
 
-The argument close_callback is the name of a function for
+The argument `close_callback` is the name of a function for
 the driver to call if the socket closes unexpectedly, i.e.
 not as the result of a [socket_close()](socket_close.md) call. The close
 callback should follow this format:
 
+~~~cxx
 void close_callback(int fd)
+~~~
 
-Where fd is the socket which has closed.  NOTE:
-close_callback is not used with DATAGRAM mode sockets.
+Where `fd` is the socket which has closed.
+NOTE: `close_callback` is not used with `DATAGRAM` mode sockets.
 
 ## RETURN VALUE
 socket_create() returns:

lib/efuns/call_out.c

@@ -15,7 +15,7 @@
 
 typedef struct pending_call_s
 {
-  int delta;
+  time_t delta;
   string_or_func_t function;
   object_t *ob;
   array_t *vs;
@@ -29,7 +29,8 @@ pending_call_t;
 
 static pending_call_t *call_list[CALLOUT_CYCLE_SIZE];
 static pending_call_t *call_list_free;
-static int num_call, call_out_time = 0;
+static time_t call_out_time = 0;
+static int num_call;
 static int unique = 0;
 
 static void free_call (pending_call_t *);
@@ -71,13 +72,10 @@ free_call (pending_call_t * cop)
 }
 
 
-/*
+/**
  * Setup a new call out.
  */
-int
-new_call_out (object_t * ob, svalue_t * fun, int delay, int num_args,
-              svalue_t * arg)
-{
+int new_call_out (object_t * ob, svalue_t * fun, time_t delay, int num_args, svalue_t* arg) {
   pending_call_t *cop, **copp;
   int tm;
 
@@ -129,8 +127,7 @@ new_call_out (object_t * ob, svalue_t * fun, int delay, int num_args,
 
   /* Find out which slot this one fits in */
   tm = (delay + current_time) & (CALLOUT_CYCLE_SIZE - 1);
-  delay =
-    (1 + (delay + current_time - call_out_time - 1) / CALLOUT_CYCLE_SIZE);
+  delay = (1 + (delay + current_time - call_out_time - 1) / CALLOUT_CYCLE_SIZE);
 
   for (copp = &call_list[tm]; *copp; copp = &(*copp)->next)
     {
@@ -269,9 +266,7 @@ call_out ()
 }
 
 
-static int
-time_left (int slot, int delay)
-{
+static time_t time_left (int slot, time_t delay) {
   int current_slot = call_out_time & (CALLOUT_CYCLE_SIZE - 1);
   if (slot > current_slot)
     {
@@ -291,11 +286,9 @@ time_left (int slot, int delay)
  * The time left until execution is returned.
  * -1 is returned if no call out pending.
  */
-int
-remove_call_out (object_t * ob, char *fun)
-{
+int remove_call_out (object_t * ob, char *fun) {
   pending_call_t **copp, *cop;
-  int delay;
+  time_t delay;
   int i;
 
   if (!ob)
@@ -313,21 +306,18 @@ remove_call_out (object_t * ob, char *fun)
                 cop->next->delta += cop->delta;
               *copp = cop->next;
               free_call (cop);
-              return time_left (i, delay);
+              return (int)time_left (i, delay);
             }
         }
     }
   return -1;
 }
 
-int
-remove_call_out_by_handle (int handle)
-{
+int remove_call_out_by_handle (int handle) {
   pending_call_t **copp, *cop;
-  int delay = 0;
+  time_t delay = 0;
 
-  for (copp = &call_list[handle & (CALLOUT_CYCLE_SIZE - 1)]; *copp;
-       copp = &(*copp)->next)
+  for (copp = &call_list[handle & (CALLOUT_CYCLE_SIZE - 1)]; *copp; copp = &(*copp)->next)
     {
       delay += (*copp)->delta;
       if ((*copp)->handle == handle)
@@ -337,33 +327,29 @@ remove_call_out_by_handle (int handle)
             cop->next->delta += cop->delta;
           *copp = cop->next;
           free_call (cop);
-          return time_left (handle & (CALLOUT_CYCLE_SIZE - 1), delay);
+          return (int)time_left (handle & (CALLOUT_CYCLE_SIZE - 1), delay);
         }
     }
   return -1;
 }
 
-int
-find_call_out_by_handle (int handle)
-{
+int find_call_out_by_handle (int handle) {
   pending_call_t *cop;
-  int delay = 0;
+  time_t delay = 0;
 
   for (cop = call_list[handle & (CALLOUT_CYCLE_SIZE - 1)]; cop;
        cop = cop->next)
     {
       delay += cop->delta;
       if (cop->handle == handle)
-        return time_left (handle & (CALLOUT_CYCLE_SIZE - 1), delay);
+        return (int)time_left (handle & (CALLOUT_CYCLE_SIZE - 1), delay);
     }
   return -1;
 }
 
-int
-find_call_out (object_t * ob, char *fun)
-{
+int find_call_out (object_t * ob, char *fun) {
   pending_call_t *cop;
-  int delay;
+  time_t delay;
   int i;
 
   if (!ob)
@@ -375,7 +361,7 @@ find_call_out (object_t * ob, char *fun)
         {
           delay += cop->delta;
           if (cop->ob == ob && strcmp (cop->function.s, fun) == 0)
-            return time_left (i, delay);
+            return (int)time_left (i, delay);
         }
     }
   return -1;
@@ -415,10 +401,9 @@ print_call_out_usage (outbuffer_t * ob, int verbose)
  * 1:	The function (string).
  * 2:	The delay.
  */
-array_t *
-get_all_call_outs ()
-{
-  int i, j, delay, tm;
+array_t* get_all_call_outs () {
+  time_t delay;
+  int i, j, tm;
   pending_call_t *cop;
   array_t *v;
 
@@ -520,7 +505,7 @@ void f_call_out (void) {
 
   if (!(current_object->flags & O_DESTRUCTED))
     {
-      ret = new_call_out (current_object, arg, arg[1].u.number, num, arg + 2);
+      ret = new_call_out (current_object, arg, (time_t)arg[1].u.number, num, arg + 2);
       /* args have been transfered; don't free them;
          also don't need to free the int */
       sp -= num + 1;
@@ -537,7 +522,7 @@ void f_call_out (void) {
 #else
   if (!(current_object->flags & O_DESTRUCTED))
     {
-      new_call_out (current_object, arg, arg[1].u.number, num, arg + 2);
+      new_call_out (current_object, arg, (time_t)arg[1].u.number, num, arg + 2);
       sp -= num + 1;
     }
   else
@@ -557,7 +542,7 @@ void f_find_call_out (void) {
 #ifdef CALLOUT_HANDLES
   if (sp->type == T_NUMBER)
     {
-      i = find_call_out_by_handle (sp->u.number);
+      i = find_call_out_by_handle ((int)sp->u.number);
     }
   else
     {				/* T_STRING */
@@ -588,7 +573,7 @@ void f_remove_call_out (void) {
         }
       else
         {
-          i = remove_call_out_by_handle (sp->u.number);
+          i = remove_call_out_by_handle ((int)sp->u.number);
         }
 #endif
     }

lib/efuns/call_out.h

@@ -4,7 +4,7 @@
 void call_out(void);
 int find_call_out_by_handle(int);
 int remove_call_out_by_handle(int);
-int new_call_out(object_t *, svalue_t *, int, int, svalue_t *);
+int new_call_out(object_t *, svalue_t *, time_t, int, svalue_t *);
 int remove_call_out(object_t *, char *);
 void remove_all_call_out(object_t *);
 int find_call_out(object_t *, char *);

lib/efuns/debug.c

@@ -82,7 +82,8 @@ void f_cache_stats (void) {
 
 #ifdef F_CALL_STACK
 void f_call_stack (void) {
-  int i, n = csp - &control_stack[0] + 1;
+  int i;
+  int n = (int)(csp - &control_stack[0] + 1);
   array_t *ret;
 
   if (sp->u.number < 0 || sp->u.number > 3)
@@ -256,14 +257,13 @@ f_malloc_status (void)
 
 
 #ifdef F_MUD_STATUS
-void
-f_mud_status (void)
-{
-  int tot, res, verbose = 0;
+void f_mud_status (void) {
+  size_t tot;
+  int res, verbose = 0;
   outbuffer_t ob;
 
   outbuf_zero (&ob);
-  verbose = (sp--)->u.number;
+  verbose = (int)(sp--)->u.number;
 
   if (reserved_area)
     res = CONFIG_INT (__RESERVED_MEM_SIZE__);
@@ -359,15 +359,14 @@ f_dump_file_descriptors (void)
 
 
 #ifdef F_MEMORY_INFO
-void
-f_memory_info (void)
-{
+void f_memory_info (void) {
   int mem;
   object_t *ob;
 
   if (st_num_arg == 0)
     {
-      int res, tot;
+      int res;
+      size_t tot;
 
       if (reserved_area)
         res = CONFIG_INT (__RESERVED_MEM_SIZE__);
@@ -402,12 +401,10 @@ f_memory_info (void)
 
 
 #ifdef F_MEMORY_SUMMARY
-static int memory_share (svalue_t *);
+static size_t memory_share (svalue_t *);
 
-static int
-node_share (mapping_t * m, mapping_node_t * elt, void *tp)
-{
-  int *t = (int *) tp;
+static int node_share (mapping_t * m, mapping_node_t * elt, void *tp) {
+  size_t *t = (size_t *) tp;
   (void)m; /* unused */
 
   *t += sizeof (mapping_node_t) - 2 * sizeof (svalue_t);
@@ -417,11 +414,9 @@ node_share (mapping_t * m, mapping_node_t * elt, void *tp)
   return 0;
 }
 
-static int
-memory_share (svalue_t * sv)
-{
-  int i, total = sizeof (svalue_t);
-  int subtotal;
+static size_t memory_share (svalue_t * sv) {
+  size_t total = sizeof (svalue_t), subtotal;
+  int i;
 
   switch (sv->type)
     {
@@ -458,8 +453,7 @@ memory_share (svalue_t * sv)
         tmp.u.arr = sv->u.fp->hdr.args;
 
         if (tmp.u.arr)
-          subtotal =
-            sizeof (funptr_hdr_t) + memory_share (&tmp) - sizeof (svalue_t);
+          subtotal = sizeof (funptr_hdr_t) + memory_share (&tmp) - sizeof (svalue_t);
         else
           subtotal = sizeof (funptr_hdr_t);
         switch (sv->u.fp->hdr.type)
@@ -509,7 +503,7 @@ fms_recurse (mapping_t * map, object_t * ob, int *idx, program_t * prog)
 
   for (i = 0; i < prog->num_variables_defined; i++)
     {
-      int size = memory_share (ob->variables + *idx + i);
+      size_t size = memory_share (ob->variables + *idx + i);
 
       sv.u.string = prog->variable_table[i];
       entry = find_for_insert (map, &sv, 0);