lib: don't assume time_t is signed.

We introduce the function c_time to convert a Lisp integer
to time_t, and num_time to do the reverse conversion.
The FFI type time-t already does this right.
(See registration of time-t in ffi_init_extra_types).

* hash.c (gen_hash_seed): The first value out of time_sec_usec
corresponds to a time_t value. We now convert this to C number
using c_time rather than c_num. Also, while we are touching
this code, the microseconds value can convert directly to
ucnum with c_unum.

* lib.c (time_sec_usec): Use num_time for seconds.
(time_string_local, time_string_utc, time_fields_local,
time_fields_utc, time_struct_local, time_struct_utc): Use c_time.
(make_time_impl, time_parse_utc): Use num_time instead of num.

* signal.h (getitimer_wrap, setitimer_wrap): Convert tv_sec
members of struct timeval using c_time and num_time.

* sysif.c (c_time, num_time): New functions.
(stat_to_struct): Convert st_atime, st_mtime and st_ctime
to Lisp using num_time instead of num.

* sysif.c (c_time, num_time): Declared.

5 files changed, 35 insertions, 21 deletions

diff --git a/hash.c b/hash.c
index 20c869bf..bde7901f 100644
--- a/hash.c
+++ b/hash.c
@@ -46,6 +46,7 @@
 #include "eval.h"
 #include "itypes.h"
 #include "arith.h"
+#include "sysif.h"
 #include "hash.h"
 
 typedef enum hash_flags {
@@ -1818,8 +1819,8 @@ static val set_hash_traversal_limit(val lim)
 static val gen_hash_seed(void)
 {
     val time = time_sec_usec();
-    ucnum sec = convert(ucnum, c_num(car(time)));
-    ucnum usec = convert(ucnum, c_num(cdr(time)));
+    ucnum sec = convert(ucnum, c_time(car(time)));
+    ucnum usec = c_unum(cdr(time));
 #if HAVE_UNISTD_H
     ucnum pid = convert(ucnum, getpid());
 #else
diff --git a/lib.c b/lib.c
index 93b0a1fa..98bb672d 100644
--- a/lib.c
+++ b/lib.c
@@ -12079,7 +12079,7 @@ val time_sec_usec(void)
   struct timeval tv;
   if (gettimeofday(&tv, 0) == -1)
     return nil;
-  return cons(num(tv.tv_sec), num(tv.tv_usec));
+  return cons(num_time(tv.tv_sec), num(tv.tv_usec));
 }
 
 #if !HAVE_GMTIME_R
@@ -12126,7 +12126,7 @@ static val string_time(struct tm *(*break_time_fn)(const time_t *, struct tm *),
 
 val time_string_local(val time, val format)
 {
-  time_t secs = c_num(time);
+  time_t secs = c_time(time);
   const wchar_t *wcfmt = c_str(format);
   char *u8fmt = utf8_dup_to(wcfmt);
   val timestr = string_time(localtime_r, u8fmt, secs);
@@ -12136,7 +12136,7 @@ val time_string_local(val time, val format)
 
 val time_string_utc(val time, val format)
 {
-  time_t secs = c_num(time);
+  time_t secs = c_time(time);
   const wchar_t *wcfmt = c_str(format);
   char *u8fmt = utf8_dup_to(wcfmt);
   val timestr = string_time(gmtime_r, u8fmt, secs);
@@ -12186,7 +12186,7 @@ static val broken_time_struct(struct tm *tms)
 val time_fields_local(val time)
 {
   struct tm tms;
-  time_t secs = c_num(time);
+  time_t secs = c_time(time);
 
   if (localtime_r(&secs, &tms) == 0)
     return nil;
@@ -12197,7 +12197,7 @@ val time_fields_local(val time)
 val time_fields_utc(val time)
 {
   struct tm tms;
-  time_t secs = c_num(time);
+  time_t secs = c_time(time);
 
   if (gmtime_r(&secs, &tms) == 0)
     return nil;
@@ -12208,7 +12208,7 @@ val time_fields_utc(val time)
 val time_struct_local(val time)
 {
   struct tm tms;
-  time_t secs = c_num(time);
+  time_t secs = c_time(time);
 
   if (localtime_r(&secs, &tms) == 0)
     return nil;
@@ -12219,7 +12219,7 @@ val time_struct_local(val time)
 val time_struct_utc(val time)
 {
   struct tm tms;
-  time_t secs = c_num(time);
+  time_t secs = c_time(time);
 
   if (gmtime_r(&secs, &tms) == 0)
     return nil;
@@ -12288,7 +12288,7 @@ static val make_time_impl(time_t (*pmktime)(struct tm *),
                     hour, minute, second, isdst);
   time = pmktime(&local);
 
-  return time == -1 ? nil : num(time);
+  return time == -1 ? nil : num_time(time);
 }
 
 val make_time(val year, val month, val day,
@@ -12458,9 +12458,9 @@ val time_parse_utc(val format, val string)
   if (!strptime_wrap(string, format, &tms))
     return nil;
 #if HAVE_TIMEGM
-  return num(timegm(&tms));
+  return num_time(timegm(&tms));
 #else
-  return num(timegm_hack(&tms));
+  return num_time(timegm_hack(&tms));
 #endif
 }
 
diff --git a/signal.c b/signal.c
index 245e2cc7..a5f91ccd 100644
--- a/signal.c
+++ b/signal.c
@@ -40,6 +40,7 @@
 #endif
 #include "lib.h"
 #include "gc.h"
+#include "sysif.h"
 #include "signal.h"
 #include "unwind.h"
 #include "eval.h"
@@ -396,8 +397,8 @@ val getitimer_wrap(val which)
   if (getitimer(c_num(which), &itv) < 0)
     return nil;
 
-  return list(tv_to_usec(num(itv.it_interval.tv_sec), num(itv.it_interval.tv_usec)),
-              tv_to_usec(num(itv.it_value.tv_sec), num(itv.it_value.tv_usec)),
+  return list(tv_to_usec(num_time(itv.it_interval.tv_sec), num(itv.it_interval.tv_usec)),
+              tv_to_usec(num_time(itv.it_value.tv_sec), num(itv.it_value.tv_usec)),
               nao);
 }
 
@@ -406,16 +407,16 @@ val setitimer_wrap(val which, val interval, val currval)
   struct itimerval itn, itv;
   const val meg = num_fast(1000000);
 
-  itn.it_interval.tv_sec = c_num(trunc(interval, meg));
+  itn.it_interval.tv_sec = c_time(trunc(interval, meg));
   itn.it_interval.tv_usec = c_num(mod(interval, meg));
-  itn.it_value.tv_sec = c_num(trunc(currval, meg));
+  itn.it_value.tv_sec = c_time(trunc(currval, meg));
   itn.it_value.tv_usec = c_num(mod(currval, meg));
 
   if (setitimer(c_num(which), &itn, &itv) < 0)
     return nil;
 
-  return list(tv_to_usec(num(itv.it_interval.tv_sec), num(itv.it_interval.tv_usec)),
-              tv_to_usec(num(itv.it_value.tv_sec), num(itv.it_value.tv_usec)),
+  return list(tv_to_usec(num_time(itv.it_interval.tv_sec), num(itv.it_interval.tv_usec)),
+              tv_to_usec(num_time(itv.it_value.tv_sec), num(itv.it_value.tv_usec)),
               nao);
 }
 
diff --git a/sysif.c b/sysif.c
index 667e3ad9..7ff7e816 100644
--- a/sysif.c
+++ b/sysif.c
@@ -778,6 +778,16 @@ static int w_fstat(val stream, struct stat *buf)
 }
 #endif
 
+time_t c_time(val time)
+{
+  return if3(convert(time_t, -1) > 0, c_unum(time), c_num(time));
+}
+
+val num_time(time_t time)
+{
+  return if3(convert(time_t, -1) > 0, unum(time), num(time));
+}
+
 #if HAVE_SYS_STAT
 static val stat_to_list(struct stat st)
 {
@@ -821,9 +831,9 @@ val stat_to_struct(struct stat st, val path)
   slotset(strct, blksize_s, zero);
   slotset(strct, blocks_s, zero);
 #endif
-  slotset(strct, atime_s, num(st.st_atime));
-  slotset(strct, mtime_s, num(st.st_mtime));
-  slotset(strct, ctime_s, num(st.st_ctime));
+  slotset(strct, atime_s, num_time(st.st_atime));
+  slotset(strct, mtime_s, num_time(st.st_mtime));
+  slotset(strct, ctime_s, num_time(st.st_ctime));
 #if HAVE_STAT_NSEC
   slotset(strct, atime_nsec_s, num(st.st_atim.tv_nsec));
   slotset(strct, mtime_nsec_s, num(st.st_mtim.tv_nsec));
diff --git a/sysif.h b/sysif.h
index cc817402..ef548d21 100644
--- a/sysif.h
+++ b/sysif.h
@@ -53,6 +53,8 @@ val usleep_wrap(val usec);
 #if HAVE_FORK_STUFF
 val exec_wrap(val file, val args_opt);
 #endif
+time_t c_time(val time);
+val num_time(time_t time);
 #if HAVE_SYS_STAT
 struct stat;
 val stat_to_struct(struct stat st, val path);