patch: fmt, os, runtime, syscall, time
This commit is contained in:
xushiwei
451
internal/lib/time/time.go
Normal file
451
internal/lib/time/time.go
Normal file
@@ -0,0 +1,451 @@
|
||||
/*
|
||||
* Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package time
|
||||
|
||||
// llgo:skipall
|
||||
import (
|
||||
_ "unsafe"
|
||||
)
|
||||
|
||||
type Time struct {
|
||||
// wall and ext encode the wall time seconds, wall time nanoseconds,
|
||||
// and optional monotonic clock reading in nanoseconds.
|
||||
//
|
||||
// From high to low bit position, wall encodes a 1-bit flag (hasMonotonic),
|
||||
// a 33-bit seconds field, and a 30-bit wall time nanoseconds field.
|
||||
// The nanoseconds field is in the range [0, 999999999].
|
||||
// If the hasMonotonic bit is 0, then the 33-bit field must be zero
|
||||
// and the full signed 64-bit wall seconds since Jan 1 year 1 is stored in ext.
|
||||
// If the hasMonotonic bit is 1, then the 33-bit field holds a 33-bit
|
||||
// unsigned wall seconds since Jan 1 year 1885, and ext holds a
|
||||
// signed 64-bit monotonic clock reading, nanoseconds since process start.
|
||||
wall uint64
|
||||
ext int64
|
||||
|
||||
// loc specifies the Location that should be used to
|
||||
// determine the minute, hour, month, day, and year
|
||||
// that correspond to this Time.
|
||||
// The nil location means UTC.
|
||||
// All UTC times are represented with loc==nil, never loc==&utcLoc.
|
||||
loc *Location
|
||||
}
|
||||
|
||||
const (
|
||||
hasMonotonic = 1 << 63
|
||||
maxWall = wallToInternal + (1<<33 - 1) // year 2157
|
||||
minWall = wallToInternal // year 1885
|
||||
nsecMask = 1<<30 - 1
|
||||
nsecShift = 30
|
||||
)
|
||||
|
||||
// These helpers for manipulating the wall and monotonic clock readings
|
||||
// take pointer receivers, even when they don't modify the time,
|
||||
// to make them cheaper to call.
|
||||
|
||||
// nsec returns the time's nanoseconds.
|
||||
func (t *Time) nsec() int32 {
|
||||
return int32(t.wall & nsecMask)
|
||||
}
|
||||
|
||||
// sec returns the time's seconds since Jan 1 year 1.
|
||||
func (t *Time) sec() int64 {
|
||||
if t.wall&hasMonotonic != 0 {
|
||||
return wallToInternal + int64(t.wall<<1>>(nsecShift+1))
|
||||
}
|
||||
return t.ext
|
||||
}
|
||||
|
||||
// unixSec returns the time's seconds since Jan 1 1970 (Unix time).
|
||||
func (t *Time) unixSec() int64 { return t.sec() + internalToUnix }
|
||||
|
||||
// addSec adds d seconds to the time.
|
||||
func (t *Time) addSec(d int64) {
|
||||
if t.wall&hasMonotonic != 0 {
|
||||
sec := int64(t.wall << 1 >> (nsecShift + 1))
|
||||
dsec := sec + d
|
||||
if 0 <= dsec && dsec <= 1<<33-1 {
|
||||
t.wall = t.wall&nsecMask | uint64(dsec)<<nsecShift | hasMonotonic
|
||||
return
|
||||
}
|
||||
// Wall second now out of range for packed field.
|
||||
// Move to ext.
|
||||
t.stripMono()
|
||||
}
|
||||
|
||||
// Check if the sum of t.ext and d overflows and handle it properly.
|
||||
sum := t.ext + d
|
||||
if (sum > t.ext) == (d > 0) {
|
||||
t.ext = sum
|
||||
} else if d > 0 {
|
||||
t.ext = 1<<63 - 1
|
||||
} else {
|
||||
t.ext = -(1<<63 - 1)
|
||||
}
|
||||
}
|
||||
|
||||
// setLoc sets the location associated with the time.
|
||||
func (t *Time) setLoc(loc *Location) {
|
||||
if loc == &utcLoc {
|
||||
loc = nil
|
||||
}
|
||||
t.stripMono()
|
||||
t.loc = loc
|
||||
}
|
||||
|
||||
// stripMono strips the monotonic clock reading in t.
|
||||
func (t *Time) stripMono() {
|
||||
if t.wall&hasMonotonic != 0 {
|
||||
t.ext = t.sec()
|
||||
t.wall &= nsecMask
|
||||
}
|
||||
}
|
||||
|
||||
// setMono sets the monotonic clock reading in t.
|
||||
// If t cannot hold a monotonic clock reading,
|
||||
// because its wall time is too large,
|
||||
// setMono is a no-op.
|
||||
func (t *Time) setMono(m int64) {
|
||||
if t.wall&hasMonotonic == 0 {
|
||||
sec := t.ext
|
||||
if sec < minWall || maxWall < sec {
|
||||
return
|
||||
}
|
||||
t.wall |= hasMonotonic | uint64(sec-minWall)<<nsecShift
|
||||
}
|
||||
t.ext = m
|
||||
}
|
||||
|
||||
// mono returns t's monotonic clock reading.
|
||||
// It returns 0 for a missing reading.
|
||||
// This function is used only for testing,
|
||||
// so it's OK that technically 0 is a valid
|
||||
// monotonic clock reading as well.
|
||||
func (t *Time) mono() int64 {
|
||||
if t.wall&hasMonotonic == 0 {
|
||||
return 0
|
||||
}
|
||||
return t.ext
|
||||
}
|
||||
|
||||
// After reports whether the time instant t is after u.
|
||||
func (t Time) After(u Time) bool {
|
||||
if t.wall&u.wall&hasMonotonic != 0 {
|
||||
return t.ext > u.ext
|
||||
}
|
||||
ts := t.sec()
|
||||
us := u.sec()
|
||||
return ts > us || ts == us && t.nsec() > u.nsec()
|
||||
}
|
||||
|
||||
// Before reports whether the time instant t is before u.
|
||||
func (t Time) Before(u Time) bool {
|
||||
if t.wall&u.wall&hasMonotonic != 0 {
|
||||
return t.ext < u.ext
|
||||
}
|
||||
ts := t.sec()
|
||||
us := u.sec()
|
||||
return ts < us || ts == us && t.nsec() < u.nsec()
|
||||
}
|
||||
|
||||
// Compare compares the time instant t with u. If t is before u, it returns -1;
|
||||
// if t is after u, it returns +1; if they're the same, it returns 0.
|
||||
func (t Time) Compare(u Time) int {
|
||||
var tc, uc int64
|
||||
if t.wall&u.wall&hasMonotonic != 0 {
|
||||
tc, uc = t.ext, u.ext
|
||||
} else {
|
||||
tc, uc = t.sec(), u.sec()
|
||||
if tc == uc {
|
||||
tc, uc = int64(t.nsec()), int64(u.nsec())
|
||||
}
|
||||
}
|
||||
switch {
|
||||
case tc < uc:
|
||||
return -1
|
||||
case tc > uc:
|
||||
return +1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// Equal reports whether t and u represent the same time instant.
|
||||
// Two times can be equal even if they are in different locations.
|
||||
// For example, 6:00 +0200 and 4:00 UTC are Equal.
|
||||
// See the documentation on the Time type for the pitfalls of using == with
|
||||
// Time values; most code should use Equal instead.
|
||||
func (t Time) Equal(u Time) bool {
|
||||
if t.wall&u.wall&hasMonotonic != 0 {
|
||||
return t.ext == u.ext
|
||||
}
|
||||
return t.sec() == u.sec() && t.nsec() == u.nsec()
|
||||
}
|
||||
|
||||
// A Month specifies a month of the year (January = 1, ...).
|
||||
type Month int
|
||||
|
||||
const (
|
||||
January Month = 1 + iota
|
||||
February
|
||||
March
|
||||
April
|
||||
May
|
||||
June
|
||||
July
|
||||
August
|
||||
September
|
||||
October
|
||||
November
|
||||
December
|
||||
)
|
||||
|
||||
// String returns the English name of the month ("January", "February", ...).
|
||||
func (m Month) String() string {
|
||||
if January <= m && m <= December {
|
||||
return longMonthNames[m-1]
|
||||
}
|
||||
buf := make([]byte, 20)
|
||||
n := fmtInt(buf, uint64(m))
|
||||
return "%!Month(" + string(buf[n:]) + ")"
|
||||
}
|
||||
|
||||
// A Weekday specifies a day of the week (Sunday = 0, ...).
|
||||
type Weekday int
|
||||
|
||||
const (
|
||||
Sunday Weekday = iota
|
||||
Monday
|
||||
Tuesday
|
||||
Wednesday
|
||||
Thursday
|
||||
Friday
|
||||
Saturday
|
||||
)
|
||||
|
||||
// String returns the English name of the day ("Sunday", "Monday", ...).
|
||||
func (d Weekday) String() string {
|
||||
if Sunday <= d && d <= Saturday {
|
||||
return longDayNames[d]
|
||||
}
|
||||
buf := make([]byte, 20)
|
||||
n := fmtInt(buf, uint64(d))
|
||||
return "%!Weekday(" + string(buf[n:]) + ")"
|
||||
}
|
||||
|
||||
const (
|
||||
secondsPerMinute = 60
|
||||
secondsPerHour = 60 * secondsPerMinute
|
||||
secondsPerDay = 24 * secondsPerHour
|
||||
secondsPerWeek = 7 * secondsPerDay
|
||||
daysPer400Years = 365*400 + 97
|
||||
daysPer100Years = 365*100 + 24
|
||||
daysPer4Years = 365*4 + 1
|
||||
)
|
||||
|
||||
// daysBefore[m] counts the number of days in a non-leap year
|
||||
// before month m begins. There is an entry for m=12, counting
|
||||
// the number of days before January of next year (365).
|
||||
var daysBefore = [...]int32{
|
||||
0,
|
||||
31,
|
||||
31 + 28,
|
||||
31 + 28 + 31,
|
||||
31 + 28 + 31 + 30,
|
||||
31 + 28 + 31 + 30 + 31,
|
||||
31 + 28 + 31 + 30 + 31 + 30,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
|
||||
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31,
|
||||
}
|
||||
|
||||
func daysIn(m Month, year int) int {
|
||||
if m == February && isLeap(year) {
|
||||
return 29
|
||||
}
|
||||
return int(daysBefore[m] - daysBefore[m-1])
|
||||
}
|
||||
|
||||
// daysSinceEpoch takes a year and returns the number of days from
|
||||
// the absolute epoch to the start of that year.
|
||||
// This is basically (year - zeroYear) * 365, but accounting for leap days.
|
||||
func daysSinceEpoch(year int) uint64 {
|
||||
y := uint64(int64(year) - absoluteZeroYear)
|
||||
|
||||
// Add in days from 400-year cycles.
|
||||
n := y / 400
|
||||
y -= 400 * n
|
||||
d := daysPer400Years * n
|
||||
|
||||
// Add in 100-year cycles.
|
||||
n = y / 100
|
||||
y -= 100 * n
|
||||
d += daysPer100Years * n
|
||||
|
||||
// Add in 4-year cycles.
|
||||
n = y / 4
|
||||
y -= 4 * n
|
||||
d += daysPer4Years * n
|
||||
|
||||
// Add in non-leap years.
|
||||
n = y
|
||||
d += 365 * n
|
||||
|
||||
return d
|
||||
}
|
||||
|
||||
const (
|
||||
// The unsigned zero year for internal calculations.
|
||||
// Must be 1 mod 400, and times before it will not compute correctly,
|
||||
// but otherwise can be changed at will.
|
||||
absoluteZeroYear = -292277022399
|
||||
|
||||
// The year of the zero Time.
|
||||
// Assumed by the unixToInternal computation below.
|
||||
internalYear = 1
|
||||
|
||||
// Offsets to convert between internal and absolute or Unix times.
|
||||
absoluteToInternal int64 = (absoluteZeroYear - internalYear) * 365.2425 * secondsPerDay
|
||||
internalToAbsolute = -absoluteToInternal
|
||||
|
||||
unixToInternal int64 = (1969*365 + 1969/4 - 1969/100 + 1969/400) * secondsPerDay
|
||||
internalToUnix int64 = -unixToInternal
|
||||
|
||||
wallToInternal int64 = (1884*365 + 1884/4 - 1884/100 + 1884/400) * secondsPerDay
|
||||
)
|
||||
|
||||
// IsZero reports whether t represents the zero time instant,
|
||||
// January 1, year 1, 00:00:00 UTC.
|
||||
func (t Time) IsZero() bool {
|
||||
return t.sec() == 0 && t.nsec() == 0
|
||||
}
|
||||
|
||||
// Date returns the Time corresponding to
|
||||
//
|
||||
// yyyy-mm-dd hh:mm:ss + nsec nanoseconds
|
||||
//
|
||||
// in the appropriate zone for that time in the given location.
|
||||
//
|
||||
// The month, day, hour, min, sec, and nsec values may be outside
|
||||
// their usual ranges and will be normalized during the conversion.
|
||||
// For example, October 32 converts to November 1.
|
||||
//
|
||||
// A daylight savings time transition skips or repeats times.
|
||||
// For example, in the United States, March 13, 2011 2:15am never occurred,
|
||||
// while November 6, 2011 1:15am occurred twice. In such cases, the
|
||||
// choice of time zone, and therefore the time, is not well-defined.
|
||||
// Date returns a time that is correct in one of the two zones involved
|
||||
// in the transition, but it does not guarantee which.
|
||||
//
|
||||
// Date panics if loc is nil.
|
||||
func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time {
|
||||
if loc == nil {
|
||||
panic("time: missing Location in call to Date")
|
||||
}
|
||||
|
||||
// Normalize month, overflowing into year.
|
||||
m := int(month) - 1
|
||||
year, m = norm(year, m, 12)
|
||||
month = Month(m) + 1
|
||||
|
||||
// Normalize nsec, sec, min, hour, overflowing into day.
|
||||
sec, nsec = norm(sec, nsec, 1e9)
|
||||
min, sec = norm(min, sec, 60)
|
||||
hour, min = norm(hour, min, 60)
|
||||
day, hour = norm(day, hour, 24)
|
||||
|
||||
// Compute days since the absolute epoch.
|
||||
d := daysSinceEpoch(year)
|
||||
|
||||
// Add in days before this month.
|
||||
d += uint64(daysBefore[month-1])
|
||||
if isLeap(year) && month >= March {
|
||||
d++ // February 29
|
||||
}
|
||||
|
||||
// Add in days before today.
|
||||
d += uint64(day - 1)
|
||||
|
||||
// Add in time elapsed today.
|
||||
abs := d * secondsPerDay
|
||||
abs += uint64(hour*secondsPerHour + min*secondsPerMinute + sec)
|
||||
|
||||
unix := int64(abs) + (absoluteToInternal + internalToUnix)
|
||||
|
||||
// Look for zone offset for expected time, so we can adjust to UTC.
|
||||
// The lookup function expects UTC, so first we pass unix in the
|
||||
// hope that it will not be too close to a zone transition,
|
||||
// and then adjust if it is.
|
||||
_, offset, start, end, _ := loc.lookup(unix)
|
||||
if offset != 0 {
|
||||
utc := unix - int64(offset)
|
||||
// If utc is valid for the time zone we found, then we have the right offset.
|
||||
// If not, we get the correct offset by looking up utc in the location.
|
||||
if utc < start || utc >= end {
|
||||
_, offset, _, _, _ = loc.lookup(utc)
|
||||
}
|
||||
unix -= int64(offset)
|
||||
}
|
||||
|
||||
t := unixTime(unix, int32(nsec))
|
||||
t.setLoc(loc)
|
||||
return t
|
||||
}
|
||||
|
||||
func unixTime(sec int64, nsec int32) Time {
|
||||
return Time{uint64(nsec), sec + unixToInternal, Local}
|
||||
}
|
||||
|
||||
func isLeap(year int) bool {
|
||||
return year%4 == 0 && (year%100 != 0 || year%400 == 0)
|
||||
}
|
||||
|
||||
// norm returns nhi, nlo such that
|
||||
//
|
||||
// hi * base + lo == nhi * base + nlo
|
||||
// 0 <= nlo < base
|
||||
func norm(hi, lo, base int) (nhi, nlo int) {
|
||||
if lo < 0 {
|
||||
n := (-lo-1)/base + 1
|
||||
hi -= n
|
||||
lo += n * base
|
||||
}
|
||||
if lo >= base {
|
||||
n := lo / base
|
||||
hi += n
|
||||
lo -= n * base
|
||||
}
|
||||
return hi, lo
|
||||
}
|
||||
|
||||
// fmtInt formats v into the tail of buf.
|
||||
// It returns the index where the output begins.
|
||||
func fmtInt(buf []byte, v uint64) int {
|
||||
w := len(buf)
|
||||
if v == 0 {
|
||||
w--
|
||||
buf[w] = '0'
|
||||
} else {
|
||||
for v > 0 {
|
||||
w--
|
||||
buf[w] = byte(v%10) + '0'
|
||||
v /= 10
|
||||
}
|
||||
}
|
||||
return w
|
||||
}
|
||||
Reference in New Issue
Block a user