1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/time/time_nix.c.v

145 lines
3.5 KiB
V
Raw Normal View History

// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
2020-01-01 14:01:03 +03:00
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module time
#include <time.h>
2020-01-01 14:01:03 +03:00
struct C.tm {
2020-12-06 17:19:39 +03:00
tm_sec int
tm_min int
tm_hour int
tm_mday int
tm_mon int
tm_year int
tm_wday int
tm_yday int
2020-06-10 12:14:55 +03:00
tm_isdst int
2020-01-01 14:01:03 +03:00
}
fn C.timegm(&C.tm) time_t
2020-12-06 17:19:39 +03:00
// fn C.gmtime_r(&tm, &gbuf)
fn C.localtime_r(t &time_t, tm &C.tm)
2020-01-01 14:01:03 +03:00
fn make_unix_time(t C.tm) int {
2020-02-08 00:10:48 +03:00
return int(C.timegm(&t))
2020-02-04 14:17:04 +03:00
}
// local returns t with the location set to local time.
pub fn (t Time) local() Time {
2020-06-10 12:14:55 +03:00
loc_tm := C.tm{}
2020-07-14 01:16:31 +03:00
C.localtime_r(time_t(&t.unix), &loc_tm)
2020-06-10 12:14:55 +03:00
return convert_ctime(loc_tm, t.microsecond)
}
type time_t = voidptr
// in most systems, these are __quad_t, which is an i64
struct C.timespec {
2020-07-15 11:22:33 +03:00
mut:
tv_sec i64
tv_nsec i64
}
// the first arg is defined in include/bits/types.h as `__S32_TYPE`, which is `int`
fn C.clock_gettime(int, &C.timespec)
fn C.nanosleep(req &C.timespec, rem &C.timespec) int
2021-01-13 17:30:54 +03:00
// sys_mono_now returns a *monotonically increasing time*, NOT a time adjusted for daylight savings, location etc.
pub fn sys_mono_now() u64 {
$if macos {
return sys_mono_now_darwin()
} $else {
ts := C.timespec{}
C.clock_gettime(C.CLOCK_MONOTONIC, &ts)
2020-12-06 17:19:39 +03:00
return u64(ts.tv_sec) * 1000000000 + u64(ts.tv_nsec)
}
}
2020-04-26 20:36:38 +03:00
// NB: vpc_now is used by `v -profile` .
// It should NOT call *any other v function*, just C functions and casts.
[inline]
fn vpc_now() u64 {
ts := C.timespec{}
C.clock_gettime(C.CLOCK_MONOTONIC, &ts)
2020-12-06 17:19:39 +03:00
return u64(ts.tv_sec) * 1000000000 + u64(ts.tv_nsec)
2020-04-26 20:36:38 +03:00
}
// The linux_* functions are placed here, since they're used on Android as well
// TODO: should `$if linux {}` be parsed on Android as well? (Android runs under the Linux kernel)
// linux_now returns the local time with high precision for most os:es
// this should be implemented properly with support for leap seconds.
// It uses the realtime clock to get and converts it to local time
fn linux_now() Time {
// get the high precision time as UTC realtime clock
// and use the nanoseconds part
mut ts := C.timespec{}
C.clock_gettime(C.CLOCK_REALTIME, &ts)
loc_tm := C.tm{}
C.localtime_r(&ts.tv_sec, &loc_tm)
2020-12-06 17:19:39 +03:00
return convert_ctime(loc_tm, int(ts.tv_nsec / 1000))
}
fn linux_utc() Time {
// get the high precision time as UTC realtime clock
// and use the nanoseconds part
mut ts := C.timespec{}
C.clock_gettime(C.CLOCK_REALTIME, &ts)
2020-12-06 17:19:39 +03:00
return unix2(int(ts.tv_sec), int(ts.tv_nsec / 1000))
}
2020-06-10 12:14:55 +03:00
// dummy to compile with all compilers
pub fn win_now() Time {
return Time{}
}
2020-06-10 12:14:55 +03:00
// dummy to compile with all compilers
pub fn win_utc() Time {
return Time{}
}
// dummy to compile with all compilers
pub struct C.timeval {
tv_sec u64
tv_usec u64
2020-06-10 12:14:55 +03:00
}
2020-07-15 11:22:33 +03:00
// return absolute timespec for now()+d
pub fn (d Duration) timespec() C.timespec {
mut ts := C.timespec{}
C.clock_gettime(C.CLOCK_REALTIME, &ts)
d_sec := d / second
d_nsec := d % second
ts.tv_sec += d_sec
ts.tv_nsec += d_nsec
if ts.tv_nsec > i64(second) {
ts.tv_nsec -= i64(second)
2020-07-15 11:22:33 +03:00
ts.tv_sec++
}
return ts
}
// return timespec of 1970/1/1
pub fn zero_timespec() C.timespec {
ts := C.timespec{
2020-12-06 17:19:39 +03:00
tv_sec: 0
2020-07-15 11:22:33 +03:00
tv_nsec: 0
}
return ts
}
// wait makes the calling thread sleep for a given duration (in nanoseconds).
2021-02-27 20:41:06 +03:00
[deprecated: 'call time.sleep(n * time.second)']
pub fn wait(duration Duration) {
ts := &C.timespec{duration / second, duration % second}
C.nanosleep(ts, C.NULL)
}
2021-02-27 20:41:06 +03:00
// sleep makes the calling thread sleep for a given duration (in nanoseconds).
pub fn sleep(duration Duration) {
ts := &C.timespec{duration / second, duration % second}
C.nanosleep(ts, C.NULL)
}