mirror of https://go.googlesource.com/go
189 lines
5.7 KiB
Go
189 lines
5.7 KiB
Go
// Copyright 2022 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package time
|
|
|
|
import "errors"
|
|
|
|
// RFC 3339 is the most commonly used format.
|
|
//
|
|
// It is implicitly used by the Time.(Marshal|Unmarshal)(Text|JSON) methods.
|
|
// Also, according to analysis on https://go.dev/issue/52746,
|
|
// RFC 3339 accounts for 57% of all explicitly specified time formats,
|
|
// with the second most popular format only being used 8% of the time.
|
|
// The overwhelming use of RFC 3339 compared to all other formats justifies
|
|
// the addition of logic to optimize formatting and parsing.
|
|
|
|
func (t Time) appendFormatRFC3339(b []byte, nanos bool) []byte {
|
|
_, offset, abs := t.locabs()
|
|
|
|
// Format date.
|
|
year, month, day, _ := absDate(abs, true)
|
|
b = appendInt(b, year, 4)
|
|
b = append(b, '-')
|
|
b = appendInt(b, int(month), 2)
|
|
b = append(b, '-')
|
|
b = appendInt(b, day, 2)
|
|
|
|
b = append(b, 'T')
|
|
|
|
// Format time.
|
|
hour, min, sec := absClock(abs)
|
|
b = appendInt(b, hour, 2)
|
|
b = append(b, ':')
|
|
b = appendInt(b, min, 2)
|
|
b = append(b, ':')
|
|
b = appendInt(b, sec, 2)
|
|
|
|
if nanos {
|
|
std := stdFracSecond(stdFracSecond9, 9, '.')
|
|
b = appendNano(b, t.Nanosecond(), std)
|
|
}
|
|
|
|
if offset == 0 {
|
|
return append(b, 'Z')
|
|
}
|
|
|
|
// Format zone.
|
|
zone := offset / 60 // convert to minutes
|
|
if zone < 0 {
|
|
b = append(b, '-')
|
|
zone = -zone
|
|
} else {
|
|
b = append(b, '+')
|
|
}
|
|
b = appendInt(b, zone/60, 2)
|
|
b = append(b, ':')
|
|
b = appendInt(b, zone%60, 2)
|
|
return b
|
|
}
|
|
|
|
func (t Time) appendStrictRFC3339(b []byte) ([]byte, error) {
|
|
n0 := len(b)
|
|
b = t.appendFormatRFC3339(b, true)
|
|
|
|
// Not all valid Go timestamps can be serialized as valid RFC 3339.
|
|
// Explicitly check for these edge cases.
|
|
// See https://go.dev/issue/4556 and https://go.dev/issue/54580.
|
|
num2 := func(b []byte) byte { return 10*(b[0]-'0') + (b[1] - '0') }
|
|
switch {
|
|
case b[n0+len("9999")] != '-': // year must be exactly 4 digits wide
|
|
return b, errors.New("year outside of range [0,9999]")
|
|
case b[len(b)-1] != 'Z':
|
|
c := b[len(b)-len("Z07:00")]
|
|
if ('0' <= c && c <= '9') || num2(b[len(b)-len("07:00"):]) >= 24 {
|
|
return b, errors.New("timezone hour outside of range [0,23]")
|
|
}
|
|
}
|
|
return b, nil
|
|
}
|
|
|
|
func parseRFC3339[bytes []byte | string](s bytes, local *Location) (Time, bool) {
|
|
// parseUint parses s as an unsigned decimal integer and
|
|
// verifies that it is within some range.
|
|
// If it is invalid or out-of-range,
|
|
// it sets ok to false and returns the min value.
|
|
ok := true
|
|
parseUint := func(s bytes, min, max int) (x int) {
|
|
for _, c := range []byte(s) {
|
|
if c < '0' || '9' < c {
|
|
ok = false
|
|
return min
|
|
}
|
|
x = x*10 + int(c) - '0'
|
|
}
|
|
if x < min || max < x {
|
|
ok = false
|
|
return min
|
|
}
|
|
return x
|
|
}
|
|
|
|
// Parse the date and time.
|
|
if len(s) < len("2006-01-02T15:04:05") {
|
|
return Time{}, false
|
|
}
|
|
year := parseUint(s[0:4], 0, 9999) // e.g., 2006
|
|
month := parseUint(s[5:7], 1, 12) // e.g., 01
|
|
day := parseUint(s[8:10], 1, daysIn(Month(month), year)) // e.g., 02
|
|
hour := parseUint(s[11:13], 0, 23) // e.g., 15
|
|
min := parseUint(s[14:16], 0, 59) // e.g., 04
|
|
sec := parseUint(s[17:19], 0, 59) // e.g., 05
|
|
if !ok || !(s[4] == '-' && s[7] == '-' && s[10] == 'T' && s[13] == ':' && s[16] == ':') {
|
|
return Time{}, false
|
|
}
|
|
s = s[19:]
|
|
|
|
// Parse the fractional second.
|
|
var nsec int
|
|
if len(s) >= 2 && s[0] == '.' && isDigit(s, 1) {
|
|
n := 2
|
|
for ; n < len(s) && isDigit(s, n); n++ {
|
|
}
|
|
nsec, _, _ = parseNanoseconds(s, n)
|
|
s = s[n:]
|
|
}
|
|
|
|
// Parse the time zone.
|
|
t := Date(year, Month(month), day, hour, min, sec, nsec, UTC)
|
|
if len(s) != 1 || s[0] != 'Z' {
|
|
if len(s) != len("-07:00") {
|
|
return Time{}, false
|
|
}
|
|
hr := parseUint(s[1:3], 0, 23) // e.g., 07
|
|
mm := parseUint(s[4:6], 0, 59) // e.g., 00
|
|
if !ok || !((s[0] == '-' || s[0] == '+') && s[3] == ':') {
|
|
return Time{}, false
|
|
}
|
|
zoneOffset := (hr*60 + mm) * 60
|
|
if s[0] == '-' {
|
|
zoneOffset *= -1
|
|
}
|
|
t.addSec(-int64(zoneOffset))
|
|
|
|
// Use local zone with the given offset if possible.
|
|
if _, offset, _, _, _ := local.lookup(t.unixSec()); offset == zoneOffset {
|
|
t.setLoc(local)
|
|
} else {
|
|
t.setLoc(FixedZone("", zoneOffset))
|
|
}
|
|
}
|
|
return t, true
|
|
}
|
|
|
|
func parseStrictRFC3339(b []byte) (Time, error) {
|
|
t, ok := parseRFC3339(b, Local)
|
|
if !ok {
|
|
t, err := Parse(RFC3339, string(b))
|
|
if err != nil {
|
|
return Time{}, err
|
|
}
|
|
|
|
// The parse template syntax cannot correctly validate RFC 3339.
|
|
// Explicitly check for cases that Parse is unable to validate for.
|
|
// See https://go.dev/issue/54580.
|
|
num2 := func(b []byte) byte { return 10*(b[0]-'0') + (b[1] - '0') }
|
|
switch {
|
|
// TODO(https://go.dev/issue/54580): Strict parsing is disabled for now.
|
|
// Enable this again with a GODEBUG opt-out.
|
|
case true:
|
|
return t, nil
|
|
case b[len("2006-01-02T")+1] == ':': // hour must be two digits
|
|
return Time{}, &ParseError{RFC3339, string(b), "15", string(b[len("2006-01-02T"):][:1]), ""}
|
|
case b[len("2006-01-02T15:04:05")] == ',': // sub-second separator must be a period
|
|
return Time{}, &ParseError{RFC3339, string(b), ".", ",", ""}
|
|
case b[len(b)-1] != 'Z':
|
|
switch {
|
|
case num2(b[len(b)-len("07:00"):]) >= 24: // timezone hour must be in range
|
|
return Time{}, &ParseError{RFC3339, string(b), "Z07:00", string(b[len(b)-len("Z07:00"):]), ": timezone hour out of range"}
|
|
case num2(b[len(b)-len("00"):]) >= 60: // timezone minute must be in range
|
|
return Time{}, &ParseError{RFC3339, string(b), "Z07:00", string(b[len(b)-len("Z07:00"):]), ": timezone minute out of range"}
|
|
}
|
|
default: // unknown error; should not occur
|
|
return Time{}, &ParseError{RFC3339, string(b), RFC3339, string(b), ""}
|
|
}
|
|
}
|
|
return t, nil
|
|
}
|