1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* time.c: make wide value more polymorphic.

Browse Source 
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@27116 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr 2010-03-30 12:58:34 +00:00
parent ee90d5d30e
commit 08f828002b
2 changed files with 108 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ChangeLog
View File

@ -1,3 +1,7 @@
Tue Mar 30 21:56:33 2010 Tanaka Akira <akr@fsij.org>
* time.c: make wide value more polymorphic.
Tue Mar 30 21:18:32 2010 NARUSE, Yui <naruse@ruby-lang.org> Tue Mar 30 21:18:32 2010 NARUSE, Yui <naruse@ruby-lang.org>
* ext/psych/extconf.rb: install psych .so to not psych/ but direct. * ext/psych/extconf.rb: install psych .so to not psych/ but direct.

206
time.c
View File

@ -57,24 +57,35 @@ typedef unsigned LONG_LONG unsigned_time_t;
#define TIMET_MIN (~(time_t)0 <= 0 ? (time_t)(((unsigned_time_t)1) << (sizeof(time_t) * CHAR_BIT - 1)) : (time_t)0) #define TIMET_MIN (~(time_t)0 <= 0 ? (time_t)(((unsigned_time_t)1) << (sizeof(time_t) * CHAR_BIT - 1)) : (time_t)0)
#if defined(HAVE_UINT64_T) && SIZEOF_LONG*2 <= SIZEOF_UINT64_T #if defined(HAVE_UINT64_T) && SIZEOF_LONG*2 <= SIZEOF_UINT64_T
# define WIDEVALUE_IS_WIDER 1 typedef uint64_t uwideint_t;
# define FIXWV_P(tv) ((tv) & 1) typedef int64_t wideint_t;
# define FIXWVtoINT64(tv) RSHIFT((SIGNED_WIDEVALUE)(tv), 1)
# define INT64toFIXWV(i64) ((WIDEVALUE)((SIGNED_WIDEVALUE)(i64) << 1 | FIXNUM_FLAG))
# define FIXWV_MAX (((int64_t)1 << 62) - 1)
# define FIXWV_MIN (-((int64_t)1 << 62))
# define POSFIXWVABLE(i64) ((i64) < FIXWV_MAX+1)
# define NEGFIXWVABLE(i64) ((i64) >= FIXWV_MIN)
# define FIXWVABLE(i64) (POSFIXWVABLE(i64) && NEGFIXWVABLE(i64))
typedef uint64_t WIDEVALUE; typedef uint64_t WIDEVALUE;
typedef int64_t SIGNED_WIDEVALUE; typedef int64_t SIGNED_WIDEVALUE;
# define WIDEVALUE_IS_WIDER 1
# define FIXWINT_P(tv) ((tv) & 1)
# define FIXWVtoINT64(tv) RSHIFT((SIGNED_WIDEVALUE)(tv), 1)
# define INT64toFIXWV(wi) ((WIDEVALUE)((SIGNED_WIDEVALUE)(wi) << 1 | FIXNUM_FLAG))
# define FIXWV_MAX (((int64_t)1 << 62) - 1)
# define FIXWV_MIN (-((int64_t)1 << 62))
# define POSFIXWVABLE(wi) ((wi) < FIXWV_MAX+1)
# define NEGFIXWVABLE(wi) ((wi) >= FIXWV_MIN)
# define FIXWVABLE(wi) (POSFIXWVABLE(wi) && NEGFIXWVABLE(wi))
# define WINT2FIXWV(i) WIDEVAL_WRAP(INT64toFIXWV(i))
# define FIXWV2WINT(w) FIXWVtoINT64(WIDEVAL_GET(w))
#else #else
# define WIDEVALUE_IS_WIDER 0 typedef unsigned long uwideint_t;
# define FIXWV_P(tv) FIXNUM_P(tv) typedef long wideint_t;
typedef VALUE WIDEVALUE; typedef VALUE WIDEVALUE;
typedef SIGNED_VALUE SIGNED_WIDEVALUE; typedef SIGNED_VALUE SIGNED_WIDEVALUE;
# define WIDEVALUE_IS_WIDER 0
# define FIXWINT_P(v) FIXNUM_P(v)
# define FIXWVABLE(i) FIXABLE(i)
# define WINT2FIXWV(i) WIDEVAL_WRAP(LONG2FIX(i))
# define FIXWV2WINT(w) FIX2LONG(WIDEVAL_GET(w))
#endif #endif
#define FIXWV_P(w) FIXWINT_P(WIDEVAL_GET(w))
#define STRUCT_WIDEVAL #define STRUCT_WIDEVAL
/* #define STRUCT_WIDEVAL */ /* #define STRUCT_WIDEVAL */
#ifdef STRUCT_WIDEVAL #ifdef STRUCT_WIDEVAL
@ -90,12 +101,26 @@ typedef unsigned LONG_LONG unsigned_time_t;
# define WIDEVAL_GET(w) (w) # define WIDEVAL_GET(w) (w)
#endif #endif
#if WIDEVALUE_IS_WIDER
static wideval_t
wint2wv(wideint_t wi)
{
if (FIXWVABLE(wi))
return WINT2FIXWV(wi);
else
return WIDEVAL_WRAP(INT64toNUM(wi));
}
# define WINT2WV(wi) wint2wv(wi)
#else
# define WINT2WV(wi) WIDEVAL_WRAP(LONG2NUM(wi))
#endif
static inline VALUE static inline VALUE
w2v(wideval_t w) w2v(wideval_t w)
{ {
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(w))) if (FIXWV_P(w))
return INT64toNUM(FIXWVtoINT64(WIDEVAL_GET(w))); return INT64toNUM(FIXWV2WINT(w));
return (VALUE)WIDEVAL_GET(w); return (VALUE)WIDEVAL_GET(w);
#else #else
return WIDEVAL_GET(w); return WIDEVAL_GET(w);
@ -116,19 +141,20 @@ xv2w_bignum(VALUE xv)
w = WIDEVAL_WRAP(xv); w = WIDEVAL_WRAP(xv);
if (RBIGNUM_POSITIVE_P(xv)) { if (RBIGNUM_POSITIVE_P(xv)) {
if (ds[len-1] < ((BDIGIT)1 << (sizeof(BDIGIT)*CHAR_BIT-2))) { if (ds[len-1] < ((BDIGIT)1 << (sizeof(BDIGIT)*CHAR_BIT-2))) {
int64_t i = 0; wideint_t i = 0;
while (len) while (len)
i = (i << sizeof(BDIGIT)*CHAR_BIT) | ds[--len]; i = (i << sizeof(BDIGIT)*CHAR_BIT) | ds[--len];
if (FIXWVABLE(i)) if (FIXWVABLE(i))
w = WIDEVAL_WRAP(INT64toFIXWV(i)); w = WINT2FIXWV(i);
} }
} }
else { else {
if (ds[len-1] < ((BDIGIT)1 << (sizeof(BDIGIT)*CHAR_BIT-2))) { if (ds[len-1] < ((BDIGIT)1 << (sizeof(BDIGIT)*CHAR_BIT-2))) {
int64_t i = 0; wideint_t i = 0;
while (len) while (len)
i = (i << sizeof(BDIGIT)*CHAR_BIT) | ds[--len]; i = (i << sizeof(BDIGIT)*CHAR_BIT) | ds[--len];
w = WIDEVAL_WRAP(INT64toFIXWV(-i)); i = -i;
w = WINT2FIXWV(i);
} }
} }
return w; return w;
@ -140,7 +166,7 @@ v2w(VALUE xv)
{ {
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXNUM_P(xv)) { if (FIXNUM_P(xv)) {
return WIDEVAL_WRAP((WIDEVALUE)(SIGNED_WIDEVALUE)(SIGNED_VALUE)xv); return WIDEVAL_WRAP((WIDEVALUE)(SIGNED_WIDEVALUE)(long)xv);
} }
else if (TYPE(xv) == T_BIGNUM && else if (TYPE(xv) == T_BIGNUM &&
RBIGNUM_LEN(xv) * sizeof(BDIGIT) <= sizeof(WIDEVALUE)) { RBIGNUM_LEN(xv) * sizeof(BDIGIT) <= sizeof(WIDEVALUE)) {
@ -155,9 +181,9 @@ static wideval_t
timet2wideval(time_t t) timet2wideval(time_t t)
{ {
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
int64_t i64 = t; wideint_t wi = t;
if (-((-FIXWV_MIN)/TIME_SCALE) <= i64 && i64 <= FIXWV_MAX/TIME_SCALE) { if (-((-FIXWV_MIN)/TIME_SCALE) <= wi && wi <= FIXWV_MAX/TIME_SCALE) {
return WIDEVAL_WRAP(INT64toFIXWV(i64 * TIME_SCALE)); return WINT2FIXWV(wi * TIME_SCALE);
} }
#endif #endif
return rb_time_magnify(v2w(TIMET2NUM(t))); return rb_time_magnify(v2w(TIMET2NUM(t)));
@ -352,7 +378,7 @@ static inline int
weq(wideval_t wx, wideval_t wy) weq(wideval_t wx, wideval_t wy)
{ {
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(wx)) && FIXWV_P(WIDEVAL_GET(wy))) { if (FIXWV_P(wx) && FIXWV_P(wy)) {
return WIDEVAL_GET(wx) == WIDEVAL_GET(wy); return WIDEVAL_GET(wx) == WIDEVAL_GET(wy);
} }
return RTEST(rb_funcall(w2v(wx), id_eq, 1, w2v(wy))); return RTEST(rb_funcall(w2v(wx), id_eq, 1, w2v(wy)));
@ -365,7 +391,7 @@ static inline int
wlt(wideval_t wx, wideval_t wy) wlt(wideval_t wx, wideval_t wy)
{ {
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(wx)) && FIXWV_P(WIDEVAL_GET(wy))) { if (FIXWV_P(wx) && FIXWV_P(wy)) {
return (SIGNED_WIDEVALUE)WIDEVAL_GET(wx) < (SIGNED_WIDEVALUE)WIDEVAL_GET(wy); return (SIGNED_WIDEVALUE)WIDEVAL_GET(wx) < (SIGNED_WIDEVALUE)WIDEVAL_GET(wy);
} }
return RTEST(rb_funcall(w2v(wx), '<', 1, w2v(wy))); return RTEST(rb_funcall(w2v(wx), '<', 1, w2v(wy)));
@ -384,10 +410,10 @@ wadd(wideval_t wx, wideval_t wy)
{ {
VALUE x; VALUE x;
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(wx)) && FIXWV_P(WIDEVAL_GET(wy))) { if (FIXWV_P(wx) && FIXWV_P(wy)) {
int64_t r = FIXWVtoINT64(WIDEVAL_GET(wx)) + FIXWVtoINT64(WIDEVAL_GET(wy)); wideint_t r = FIXWV2WINT(wx) + FIXWV2WINT(wy);
if (FIXWVABLE(r)) { if (FIXWVABLE(r)) {
return WIDEVAL_WRAP(INT64toFIXWV(r)); return WINT2FIXWV(r);
} }
return v2w(INT64toNUM(r)); return v2w(INT64toNUM(r));
} }
@ -403,10 +429,10 @@ wsub(wideval_t wx, wideval_t wy)
{ {
VALUE x; VALUE x;
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(wx)) && FIXWV_P(WIDEVAL_GET(wy))) { if (FIXWV_P(wx) && FIXWV_P(wy)) {
int64_t r = FIXWVtoINT64(WIDEVAL_GET(wx)) - FIXWVtoINT64(WIDEVAL_GET(wy)); wideint_t r = FIXWV2WINT(wx) - FIXWV2WINT(wy);
if (FIXWVABLE(r)) { if (FIXWVABLE(r)) {
return WIDEVAL_WRAP(INT64toFIXWV(r)); return WINT2FIXWV(r);
} }
return v2w(INT64toNUM(r)); return v2w(INT64toNUM(r));
} }
@ -423,14 +449,14 @@ wmul(wideval_t wx, wideval_t wy)
{ {
VALUE x; VALUE x;
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(wx)) && FIXWV_P(WIDEVAL_GET(wy))) { if (FIXWV_P(wx) && FIXWV_P(wy)) {
int64_t a, b, c; wideint_t a, b, c;
a = FIXWVtoINT64(WIDEVAL_GET(wx)); a = FIXWV2WINT(wx);
if (a == 0) return wx; if (a == 0) return wx;
b = FIXWVtoINT64(WIDEVAL_GET(wy)); b = FIXWV2WINT(wy);
c = a * b; c = a * b;
if (c / a == b && FIXWVABLE(c)) { if (c / a == b && FIXWVABLE(c)) {
return WIDEVAL_WRAP(INT64toFIXWV(c)); return WINT2FIXWV(c);
} }
} }
#endif #endif
@ -444,10 +470,10 @@ wcmp(wideval_t wx, wideval_t wy)
{ {
VALUE x, y; VALUE x, y;
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(wx)) && FIXWV_P(WIDEVAL_GET(wy))) { if (FIXWV_P(wx) && FIXWV_P(wy)) {
int64_t a, b; wideint_t a, b;
a = FIXWVtoINT64(WIDEVAL_GET(wx)); a = FIXWV2WINT(wx);
b = FIXWVtoINT64(WIDEVAL_GET(wy)); b = FIXWV2WINT(wy);
if (a < b) if (a < b)
return -1; return -1;
if (a > b) if (a > b)
@ -465,16 +491,14 @@ wquo(wideval_t wx, wideval_t wy)
{ {
VALUE x, y, ret; VALUE x, y, ret;
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(wx)) && FIXWV_P(WIDEVAL_GET(wy))) { if (FIXWV_P(wx) && FIXWV_P(wy)) {
int64_t a, b, c; wideint_t a, b, c;
a = FIXWVtoINT64(WIDEVAL_GET(wx)); a = FIXWV2WINT(wx);
b = FIXWVtoINT64(WIDEVAL_GET(wy)); b = FIXWV2WINT(wy);
if (b == 0) rb_num_zerodiv(); if (b == 0) rb_num_zerodiv();
c = a / b; c = a / b;
if (c * b == a) { if (c * b == a) {
if (FIXWVABLE(c)) return WINT2WV(c);
return WIDEVAL_WRAP(INT64toFIXWV(c));
return WIDEVAL_WRAP(INT64toNUM(c));
} }
} }
#endif #endif
@ -496,28 +520,25 @@ wdivmodv(wideval_t wn, wideval_t wd, wideval_t *wq, wideval_t *wr)
{ {
VALUE tmp, ary; VALUE tmp, ary;
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(wn)) && FIXWV_P(WIDEVAL_GET(wd))) { if (FIXWV_P(wn) && FIXWV_P(wd)) {
int64_t n, d, q, r; wideint_t n, d, q, r;
d = FIXWVtoINT64(WIDEVAL_GET(wd)); d = FIXWV2WINT(wd);
if (d == 0) rb_num_zerodiv(); if (d == 0) rb_num_zerodiv();
if (d == 1) { if (d == 1) {
*wq = wn; *wq = wn;
*wr = WIDEVAL_WRAP(INT64toFIXWV(0)); *wr = WINT2FIXWV(0);
return; return;
} }
if (d == -1) { if (d == -1) {
int64_t xneg = -FIXWVtoINT64(WIDEVAL_GET(wn)); wideint_t xneg = -FIXWV2WINT(wn);
if (FIXWVABLE(xneg)) *wq = WINT2WV(xneg);
*wq = WIDEVAL_WRAP(INT64toFIXWV(xneg)); *wr = WINT2FIXWV(0);
else
*wq = WIDEVAL_WRAP(INT64toNUM(xneg));
*wr = WIDEVAL_WRAP(INT64toFIXWV(0));
return; return;
} }
n = FIXWVtoINT64(WIDEVAL_GET(wn)); n = FIXWV2WINT(wn);
if (n == 0) { if (n == 0) {
*wq = WIDEVAL_WRAP(INT64toFIXWV(0)); *wq = WINT2FIXWV(0);
*wr = WIDEVAL_WRAP(INT64toFIXWV(0)); *wr = WINT2FIXWV(0);
return; return;
} }
if (d < 0) { if (d < 0) {
@ -540,8 +561,8 @@ wdivmodv(wideval_t wn, wideval_t wd, wideval_t *wq, wideval_t *wr)
r = n % d; r = n % d;
} }
} }
*wq = WIDEVAL_WRAP(INT64toFIXWV(q)); *wq = WINT2FIXWV(q);
*wr = WIDEVAL_WRAP(INT64toFIXWV(r)); *wr = WINT2FIXWV(r);
return; return;
} }
#endif #endif
@ -603,57 +624,38 @@ num_exact(VALUE v)
static wideval_t static wideval_t
rb_time_magnify(wideval_t w) rb_time_magnify(wideval_t w)
{ {
if (FIXWV_P(WIDEVAL_GET(w))) { if (FIXWV_P(w)) {
#if WIDEVALUE_IS_WIDER wideint_t a, b, c;
int64_t a, b, c; a = FIXWV2WINT(w);
a = FIXWVtoINT64(WIDEVAL_GET(w));
if (a == 0) { if (a == 0) {
return WIDEVAL_WRAP(INT64toFIXWV(0)); return WINT2FIXWV(0);
} }
b = TIME_SCALE; b = TIME_SCALE;
c = a * b; c = a * b;
if (c / b == a) { if (c / b == a) {
if (FIXWVABLE(c)) { if (FIXWVABLE(c)) {
return WIDEVAL_WRAP(INT64toFIXWV(c)); return WINT2FIXWV(c);
} }
} }
#else
long a, b, c;
a = FIX2LONG(WIDEVAL_GET(w));
if (a == 0) {
return WIDEVAL_WRAP(INT2FIX(0));
}
b = TIME_SCALE;
c = a * b;
if (c / b == a) {
return WIDEVAL_WRAP(LONG2NUM(c));
}
#endif
} }
#if WIDEVALUE_IS_WIDER return wmul(w, WINT2FIXWV(TIME_SCALE));
return wmul(w, WIDEVAL_WRAP(INT64toFIXWV(TIME_SCALE)));
#else
return wmul(w, WIDEVAL_WRAP(INT2FIX(TIME_SCALE)));
#endif
} }
static wideval_t static wideval_t
rb_time_unmagnify(wideval_t w) rb_time_unmagnify(wideval_t w)
{ {
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(w))) { if (FIXWV_P(w)) {
int64_t a, b, c; wideint_t a, b, c;
a = FIXWVtoINT64(WIDEVAL_GET(w)); a = FIXWV2WINT(w);
b = TIME_SCALE; b = TIME_SCALE;
c = a / b; c = a / b;
if (c * b == a) { if (c * b == a) {
return WIDEVAL_WRAP(INT64toFIXWV(c)); return WINT2FIXWV(c);
} }
} }
return wquo(w, WIDEVAL_WRAP(INT64toFIXWV(TIME_SCALE)));
#else
return wquo(w, WIDEVAL_WRAP(INT2FIX(TIME_SCALE)));
#endif #endif
return wquo(w, WINT2FIXWV(TIME_SCALE));
} }
static VALUE static VALUE
@ -661,15 +663,15 @@ rb_time_unmagnify_to_float(wideval_t w)
{ {
VALUE v; VALUE v;
#if WIDEVALUE_IS_WIDER #if WIDEVALUE_IS_WIDER
if (FIXWV_P(WIDEVAL_GET(w))) { if (FIXWV_P(w)) {
int64_t a, b, c; wideint_t a, b, c;
a = FIXWVtoINT64(WIDEVAL_GET(w)); a = FIXWV2WINT(w);
b = TIME_SCALE; b = TIME_SCALE;
c = a / b; c = a / b;
if (c * b == a) { if (c * b == a) {
return DBL2NUM((double)c); return DBL2NUM((double)c);
} }
v = DBL2NUM(FIXWVtoINT64(WIDEVAL_GET(w))); v = DBL2NUM(FIXWV2WINT(w));
return quo(v, DBL2NUM(TIME_SCALE)); return quo(v, DBL2NUM(TIME_SCALE));
} }
#endif #endif
@ -1069,7 +1071,7 @@ timegmw(struct vtm *vtm)
timew = timegmw_noleapsecond(vtm); timew = timegmw_noleapsecond(vtm);
if (wlt(TIMET2WIDEVAL(known_leap_seconds_limit), timew)) { if (wlt(TIMET2WIDEVAL(known_leap_seconds_limit), timew)) {
return wadd(timew, rb_time_magnify(v2w(INT2NUM(number_of_leap_seconds_known)))); return wadd(timew, rb_time_magnify(WINT2WV(number_of_leap_seconds_known)));
} }
tm.tm_year = rb_long2int(NUM2LONG(vtm->year) - 1900); tm.tm_year = rb_long2int(NUM2LONG(vtm->year) - 1900);
@ -1102,7 +1104,7 @@ gmtimew(wideval_t timew, struct vtm *result)
init_leap_second_info(); init_leap_second_info();
if (wlt(TIMET2WIDEVAL(known_leap_seconds_limit), timew)) { if (wlt(TIMET2WIDEVAL(known_leap_seconds_limit), timew)) {
timew = wsub(timew, rb_time_magnify(v2w(INT2NUM(number_of_leap_seconds_known)))); timew = wsub(timew, rb_time_magnify(WINT2WV(number_of_leap_seconds_known)));
gmtimew_noleapsecond(timew, result); gmtimew_noleapsecond(timew, result);
return result; return result;
} }
@ -1419,10 +1421,10 @@ timew_out_of_timet_range(wideval_t timew)
{ {
VALUE timexv; VALUE timexv;
#if WIDEVALUE_IS_WIDER && SIZEOF_TIME_T < SIZEOF_INT64_T #if WIDEVALUE_IS_WIDER && SIZEOF_TIME_T < SIZEOF_INT64_T
if (FIXWV_P(WIDEVAL_GET(timew))) { if (FIXWV_P(timew)) {
int64_t t = FIXWVtoINT64(WIDEVAL_GET(timew)); wideint_t t = FIXWV2WINT(timew);
if (t < TIME_SCALE * (int64_t)TIMET_MIN || if (t < TIME_SCALE * (wideint_t)TIMET_MIN ||
TIME_SCALE * (1 + (int64_t)TIMET_MAX) <= t) TIME_SCALE * (1 + (wideint_t)TIMET_MAX) <= t)
return 1; return 1;
return 0; return 0;
} }
@ -1529,7 +1531,7 @@ time_mark(void *ptr)
{ {
struct time_object *tobj = ptr; struct time_object *tobj = ptr;
if (!tobj) return; if (!tobj) return;
if (!FIXWV_P(WIDEVAL_GET(tobj->timew))) if (!FIXWV_P(tobj->timew))
rb_gc_mark(w2v(tobj->timew)); rb_gc_mark(w2v(tobj->timew));
rb_gc_mark(tobj->vtm.year); rb_gc_mark(tobj->vtm.year);
rb_gc_mark(tobj->vtm.subsecx); rb_gc_mark(tobj->vtm.subsecx);
@ -1581,7 +1583,7 @@ timespec2timew(struct timespec *ts)
timew = TIMET2WIDEVAL(ts->tv_sec); timew = TIMET2WIDEVAL(ts->tv_sec);
if (ts->tv_nsec) if (ts->tv_nsec)
timew = wadd(timew, wmulquoll(v2w(LONG2NUM(ts->tv_nsec)), TIME_SCALE, 1000000000)); timew = wadd(timew, wmulquoll(WINT2WV(ts->tv_nsec), TIME_SCALE, 1000000000));
return timew; return timew;
} }