Merge pull request #43056 from ydb-platform/merge-rightlib-260610-0127HEADmain

1 files changed, 0 insertions, 709 deletions

diff --git a/contrib/go/_std_1.25/src/time/zoneinfo.go b/contrib/go/_std_1.25/src/time/zoneinfo.go
deleted file mode 100644
index f0444a5d9da..00000000000
--- a/contrib/go/_std_1.25/src/time/zoneinfo.go
+++ /dev/null
@@ -1,709 +0,0 @@
-// Copyright 2011 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"
-	"sync"
-	"syscall"
-)
-
-//go:generate env ZONEINFO=$GOROOT/lib/time/zoneinfo.zip go run genzabbrs.go -output zoneinfo_abbrs_windows.go
-
-// A Location maps time instants to the zone in use at that time.
-// Typically, the Location represents the collection of time offsets
-// in use in a geographical area. For many Locations the time offset varies
-// depending on whether daylight savings time is in use at the time instant.
-//
-// Location is used to provide a time zone in a printed Time value and for
-// calculations involving intervals that may cross daylight savings time
-// boundaries.
-type Location struct {
-	name string
-	zone []zone
-	tx   []zoneTrans
-
-	// The tzdata information can be followed by a string that describes
-	// how to handle DST transitions not recorded in zoneTrans.
-	// The format is the TZ environment variable without a colon; see
-	// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html.
-	// Example string, for America/Los_Angeles: PST8PDT,M3.2.0,M11.1.0
-	extend string
-
-	// Most lookups will be for the current time.
-	// To avoid the binary search through tx, keep a
-	// static one-element cache that gives the correct
-	// zone for the time when the Location was created.
-	// if cacheStart <= t < cacheEnd,
-	// lookup can return cacheZone.
-	// The units for cacheStart and cacheEnd are seconds
-	// since January 1, 1970 UTC, to match the argument
-	// to lookup.
-	cacheStart int64
-	cacheEnd   int64
-	cacheZone  *zone
-}
-
-// A zone represents a single time zone such as CET.
-type zone struct {
-	name   string // abbreviated name, "CET"
-	offset int    // seconds east of UTC
-	isDST  bool   // is this zone Daylight Savings Time?
-}
-
-// A zoneTrans represents a single time zone transition.
-type zoneTrans struct {
-	when         int64 // transition time, in seconds since 1970 GMT
-	index        uint8 // the index of the zone that goes into effect at that time
-	isstd, isutc bool  // ignored - no idea what these mean
-}
-
-// alpha and omega are the beginning and end of time for zone
-// transitions.
-const (
-	alpha = -1 << 63  // math.MinInt64
-	omega = 1<<63 - 1 // math.MaxInt64
-)
-
-// UTC represents Universal Coordinated Time (UTC).
-var UTC *Location = &utcLoc
-
-// utcLoc is separate so that get can refer to &utcLoc
-// and ensure that it never returns a nil *Location,
-// even if a badly behaved client has changed UTC.
-var utcLoc = Location{name: "UTC"}
-
-// Local represents the system's local time zone.
-// On Unix systems, Local consults the TZ environment
-// variable to find the time zone to use. No TZ means
-// use the system default /etc/localtime.
-// TZ="" means use UTC.
-// TZ="foo" means use file foo in the system timezone directory.
-var Local *Location = &localLoc
-
-// localLoc is separate so that initLocal can initialize
-// it even if a client has changed Local.
-var localLoc Location
-var localOnce sync.Once
-
-func (l *Location) get() *Location {
-	if l == nil {
-		return &utcLoc
-	}
-	if l == &localLoc {
-		localOnce.Do(initLocal)
-	}
-	return l
-}
-
-// String returns a descriptive name for the time zone information,
-// corresponding to the name argument to [LoadLocation] or [FixedZone].
-func (l *Location) String() string {
-	return l.get().name
-}
-
-var unnamedFixedZones []*Location
-var unnamedFixedZonesOnce sync.Once
-
-// FixedZone returns a [Location] that always uses
-// the given zone name and offset (seconds east of UTC).
-func FixedZone(name string, offset int) *Location {
-	// Most calls to FixedZone have an unnamed zone with an offset by the hour.
-	// Optimize for that case by returning the same *Location for a given hour.
-	const hoursBeforeUTC = 12
-	const hoursAfterUTC = 14
-	hour := offset / 60 / 60
-	if name == "" && -hoursBeforeUTC <= hour && hour <= +hoursAfterUTC && hour*60*60 == offset {
-		unnamedFixedZonesOnce.Do(func() {
-			unnamedFixedZones = make([]*Location, hoursBeforeUTC+1+hoursAfterUTC)
-			for hr := -hoursBeforeUTC; hr <= +hoursAfterUTC; hr++ {
-				unnamedFixedZones[hr+hoursBeforeUTC] = fixedZone("", hr*60*60)
-			}
-		})
-		return unnamedFixedZones[hour+hoursBeforeUTC]
-	}
-	return fixedZone(name, offset)
-}
-
-func fixedZone(name string, offset int) *Location {
-	l := &Location{
-		name:       name,
-		zone:       []zone{{name, offset, false}},
-		tx:         []zoneTrans{{alpha, 0, false, false}},
-		cacheStart: alpha,
-		cacheEnd:   omega,
-	}
-	l.cacheZone = &l.zone[0]
-	return l
-}
-
-// lookup returns information about the time zone in use at an
-// instant in time expressed as seconds since January 1, 1970 00:00:00 UTC.
-//
-// The returned information gives the name of the zone (such as "CET"),
-// the start and end times bracketing sec when that zone is in effect,
-// the offset in seconds east of UTC (such as -5*60*60), and whether
-// the daylight savings is being observed at that time.
-func (l *Location) lookup(sec int64) (name string, offset int, start, end int64, isDST bool) {
-	l = l.get()
-
-	if len(l.zone) == 0 {
-		name = "UTC"
-		offset = 0
-		start = alpha
-		end = omega
-		isDST = false
-		return
-	}
-
-	if zone := l.cacheZone; zone != nil && l.cacheStart <= sec && sec < l.cacheEnd {
-		name = zone.name
-		offset = zone.offset
-		start = l.cacheStart
-		end = l.cacheEnd
-		isDST = zone.isDST
-		return
-	}
-
-	if len(l.tx) == 0 || sec < l.tx[0].when {
-		zone := &l.zone[l.lookupFirstZone()]
-		name = zone.name
-		offset = zone.offset
-		start = alpha
-		if len(l.tx) > 0 {
-			end = l.tx[0].when
-		} else {
-			end = omega
-		}
-		isDST = zone.isDST
-		return
-	}
-
-	// Binary search for entry with largest time <= sec.
-	// Not using sort.Search to avoid dependencies.
-	tx := l.tx
-	end = omega
-	lo := 0
-	hi := len(tx)
-	for hi-lo > 1 {
-		m := int(uint(lo+hi) >> 1)
-		lim := tx[m].when
-		if sec < lim {
-			end = lim
-			hi = m
-		} else {
-			lo = m
-		}
-	}
-	zone := &l.zone[tx[lo].index]
-	name = zone.name
-	offset = zone.offset
-	start = tx[lo].when
-	// end = maintained during the search
-	isDST = zone.isDST
-
-	// If we're at the end of the known zone transitions,
-	// try the extend string.
-	if lo == len(tx)-1 && l.extend != "" {
-		if ename, eoffset, estart, eend, eisDST, ok := tzset(l.extend, start, sec); ok {
-			return ename, eoffset, estart, eend, eisDST
-		}
-	}
-
-	return
-}
-
-// lookupFirstZone returns the index of the time zone to use for times
-// before the first transition time, or when there are no transition
-// times.
-//
-// The reference implementation in localtime.c from
-// https://www.iana.org/time-zones/repository/releases/tzcode2013g.tar.gz
-// implements the following algorithm for these cases:
-//  1. If the first zone is unused by the transitions, use it.
-//  2. Otherwise, if there are transition times, and the first
-//     transition is to a zone in daylight time, find the first
-//     non-daylight-time zone before and closest to the first transition
-//     zone.
-//  3. Otherwise, use the first zone that is not daylight time, if
-//     there is one.
-//  4. Otherwise, use the first zone.
-func (l *Location) lookupFirstZone() int {
-	// Case 1.
-	if !l.firstZoneUsed() {
-		return 0
-	}
-
-	// Case 2.
-	if len(l.tx) > 0 && l.zone[l.tx[0].index].isDST {
-		for zi := int(l.tx[0].index) - 1; zi >= 0; zi-- {
-			if !l.zone[zi].isDST {
-				return zi
-			}
-		}
-	}
-
-	// Case 3.
-	for zi := range l.zone {
-		if !l.zone[zi].isDST {
-			return zi
-		}
-	}
-
-	// Case 4.
-	return 0
-}
-
-// firstZoneUsed reports whether the first zone is used by some
-// transition.
-func (l *Location) firstZoneUsed() bool {
-	for _, tx := range l.tx {
-		if tx.index == 0 {
-			return true
-		}
-	}
-	return false
-}
-
-// tzset takes a timezone string like the one found in the TZ environment
-// variable, the time of the last time zone transition expressed as seconds
-// since January 1, 1970 00:00:00 UTC, and a time expressed the same way.
-// We call this a tzset string since in C the function tzset reads TZ.
-// The return values are as for lookup, plus ok which reports whether the
-// parse succeeded.
-func tzset(s string, lastTxSec, sec int64) (name string, offset int, start, end int64, isDST, ok bool) {
-	var (
-		stdName, dstName     string
-		stdOffset, dstOffset int
-	)
-
-	stdName, s, ok = tzsetName(s)
-	if ok {
-		stdOffset, s, ok = tzsetOffset(s)
-	}
-	if !ok {
-		return "", 0, 0, 0, false, false
-	}
-
-	// The numbers in the tzset string are added to local time to get UTC,
-	// but our offsets are added to UTC to get local time,
-	// so we negate the number we see here.
-	stdOffset = -stdOffset
-
-	if len(s) == 0 || s[0] == ',' {
-		// No daylight savings time.
-		return stdName, stdOffset, lastTxSec, omega, false, true
-	}
-
-	dstName, s, ok = tzsetName(s)
-	if ok {
-		if len(s) == 0 || s[0] == ',' {
-			dstOffset = stdOffset + secondsPerHour
-		} else {
-			dstOffset, s, ok = tzsetOffset(s)
-			dstOffset = -dstOffset // as with stdOffset, above
-		}
-	}
-	if !ok {
-		return "", 0, 0, 0, false, false
-	}
-
-	if len(s) == 0 {
-		// Default DST rules per tzcode.
-		s = ",M3.2.0,M11.1.0"
-	}
-	// The TZ definition does not mention ';' here but tzcode accepts it.
-	if s[0] != ',' && s[0] != ';' {
-		return "", 0, 0, 0, false, false
-	}
-	s = s[1:]
-
-	var startRule, endRule rule
-	startRule, s, ok = tzsetRule(s)
-	if !ok || len(s) == 0 || s[0] != ',' {
-		return "", 0, 0, 0, false, false
-	}
-	s = s[1:]
-	endRule, s, ok = tzsetRule(s)
-	if !ok || len(s) > 0 {
-		return "", 0, 0, 0, false, false
-	}
-
-	// Compute start of year in seconds since Unix epoch,
-	// and seconds since then to get to sec.
-	year, yday := absSeconds(sec + unixToInternal + internalToAbsolute).days().yearYday()
-	ysec := int64((yday-1)*secondsPerDay) + sec%secondsPerDay
-	ystart := sec - ysec
-
-	startSec := int64(tzruleTime(year, startRule, stdOffset))
-	endSec := int64(tzruleTime(year, endRule, dstOffset))
-	dstIsDST, stdIsDST := true, false
-	// Note: this is a flipping of "DST" and "STD" while retaining the labels
-	// This happens in southern hemispheres. The labelling here thus is a little
-	// inconsistent with the goal.
-	if endSec < startSec {
-		startSec, endSec = endSec, startSec
-		stdName, dstName = dstName, stdName
-		stdOffset, dstOffset = dstOffset, stdOffset
-		stdIsDST, dstIsDST = dstIsDST, stdIsDST
-	}
-
-	// The start and end values that we return are accurate
-	// close to a daylight savings transition, but are otherwise
-	// just the start and end of the year. That suffices for
-	// the only caller that cares, which is Date.
-	if ysec < startSec {
-		return stdName, stdOffset, ystart, startSec + ystart, stdIsDST, true
-	} else if ysec >= endSec {
-		return stdName, stdOffset, endSec + ystart, ystart + 365*secondsPerDay, stdIsDST, true
-	} else {
-		return dstName, dstOffset, startSec + ystart, endSec + ystart, dstIsDST, true
-	}
-}
-
-// tzsetName returns the timezone name at the start of the tzset string s,
-// and the remainder of s, and reports whether the parsing is OK.
-func tzsetName(s string) (string, string, bool) {
-	if len(s) == 0 {
-		return "", "", false
-	}
-	if s[0] != '<' {
-		for i, r := range s {
-			switch r {
-			case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ',', '-', '+':
-				if i < 3 {
-					return "", "", false
-				}
-				return s[:i], s[i:], true
-			}
-		}
-		if len(s) < 3 {
-			return "", "", false
-		}
-		return s, "", true
-	} else {
-		for i, r := range s {
-			if r == '>' {
-				return s[1:i], s[i+1:], true
-			}
-		}
-		return "", "", false
-	}
-}
-
-// tzsetOffset returns the timezone offset at the start of the tzset string s,
-// and the remainder of s, and reports whether the parsing is OK.
-// The timezone offset is returned as a number of seconds.
-func tzsetOffset(s string) (offset int, rest string, ok bool) {
-	if len(s) == 0 {
-		return 0, "", false
-	}
-	neg := false
-	if s[0] == '+' {
-		s = s[1:]
-	} else if s[0] == '-' {
-		s = s[1:]
-		neg = true
-	}
-
-	// The tzdata code permits values up to 24 * 7 here,
-	// although POSIX does not.
-	var hours int
-	hours, s, ok = tzsetNum(s, 0, 24*7)
-	if !ok {
-		return 0, "", false
-	}
-	off := hours * secondsPerHour
-	if len(s) == 0 || s[0] != ':' {
-		if neg {
-			off = -off
-		}
-		return off, s, true
-	}
-
-	var mins int
-	mins, s, ok = tzsetNum(s[1:], 0, 59)
-	if !ok {
-		return 0, "", false
-	}
-	off += mins * secondsPerMinute
-	if len(s) == 0 || s[0] != ':' {
-		if neg {
-			off = -off
-		}
-		return off, s, true
-	}
-
-	var secs int
-	secs, s, ok = tzsetNum(s[1:], 0, 59)
-	if !ok {
-		return 0, "", false
-	}
-	off += secs
-
-	if neg {
-		off = -off
-	}
-	return off, s, true
-}
-
-// ruleKind is the kinds of rules that can be seen in a tzset string.
-type ruleKind int
-
-const (
-	ruleJulian ruleKind = iota
-	ruleDOY
-	ruleMonthWeekDay
-)
-
-// rule is a rule read from a tzset string.
-type rule struct {
-	kind ruleKind
-	day  int
-	week int
-	mon  int
-	time int // transition time
-}
-
-// tzsetRule parses a rule from a tzset string.
-// It returns the rule, and the remainder of the string, and reports success.
-func tzsetRule(s string) (rule, string, bool) {
-	var r rule
-	if len(s) == 0 {
-		return rule{}, "", false
-	}
-	ok := false
-	if s[0] == 'J' {
-		var jday int
-		jday, s, ok = tzsetNum(s[1:], 1, 365)
-		if !ok {
-			return rule{}, "", false
-		}
-		r.kind = ruleJulian
-		r.day = jday
-	} else if s[0] == 'M' {
-		var mon int
-		mon, s, ok = tzsetNum(s[1:], 1, 12)
-		if !ok || len(s) == 0 || s[0] != '.' {
-			return rule{}, "", false
-
-		}
-		var week int
-		week, s, ok = tzsetNum(s[1:], 1, 5)
-		if !ok || len(s) == 0 || s[0] != '.' {
-			return rule{}, "", false
-		}
-		var day int
-		day, s, ok = tzsetNum(s[1:], 0, 6)
-		if !ok {
-			return rule{}, "", false
-		}
-		r.kind = ruleMonthWeekDay
-		r.day = day
-		r.week = week
-		r.mon = mon
-	} else {
-		var day int
-		day, s, ok = tzsetNum(s, 0, 365)
-		if !ok {
-			return rule{}, "", false
-		}
-		r.kind = ruleDOY
-		r.day = day
-	}
-
-	if len(s) == 0 || s[0] != '/' {
-		r.time = 2 * secondsPerHour // 2am is the default
-		return r, s, true
-	}
-
-	offset, s, ok := tzsetOffset(s[1:])
-	if !ok {
-		return rule{}, "", false
-	}
-	r.time = offset
-
-	return r, s, true
-}
-
-// tzsetNum parses a number from a tzset string.
-// It returns the number, and the remainder of the string, and reports success.
-// The number must be between min and max.
-func tzsetNum(s string, min, max int) (num int, rest string, ok bool) {
-	if len(s) == 0 {
-		return 0, "", false
-	}
-	num = 0
-	for i, r := range s {
-		if r < '0' || r > '9' {
-			if i == 0 || num < min {
-				return 0, "", false
-			}
-			return num, s[i:], true
-		}
-		num *= 10
-		num += int(r) - '0'
-		if num > max {
-			return 0, "", false
-		}
-	}
-	if num < min {
-		return 0, "", false
-	}
-	return num, "", true
-}
-
-// tzruleTime takes a year, a rule, and a timezone offset,
-// and returns the number of seconds since the start of the year
-// that the rule takes effect.
-func tzruleTime(year int, r rule, off int) int {
-	var s int
-	switch r.kind {
-	case ruleJulian:
-		s = (r.day - 1) * secondsPerDay
-		if isLeap(year) && r.day >= 60 {
-			s += secondsPerDay
-		}
-	case ruleDOY:
-		s = r.day * secondsPerDay
-	case ruleMonthWeekDay:
-		// Zeller's Congruence.
-		m1 := (r.mon+9)%12 + 1
-		yy0 := year
-		if r.mon <= 2 {
-			yy0--
-		}
-		yy1 := yy0 / 100
-		yy2 := yy0 % 100
-		dow := ((26*m1-2)/10 + 1 + yy2 + yy2/4 + yy1/4 - 2*yy1) % 7
-		if dow < 0 {
-			dow += 7
-		}
-		// Now dow is the day-of-week of the first day of r.mon.
-		// Get the day-of-month of the first "dow" day.
-		d := r.day - dow
-		if d < 0 {
-			d += 7
-		}
-		for i := 1; i < r.week; i++ {
-			if d+7 >= daysIn(Month(r.mon), year) {
-				break
-			}
-			d += 7
-		}
-		d += daysBefore(Month(r.mon))
-		if isLeap(year) && r.mon > 2 {
-			d++
-		}
-		s = d * secondsPerDay
-	}
-
-	return s + r.time - off
-}
-
-// lookupName returns information about the time zone with
-// the given name (such as "EST") at the given pseudo-Unix time
-// (what the given time of day would be in UTC).
-func (l *Location) lookupName(name string, unix int64) (offset int, ok bool) {
-	l = l.get()
-
-	// First try for a zone with the right name that was actually
-	// in effect at the given time. (In Sydney, Australia, both standard
-	// and daylight-savings time are abbreviated "EST". Using the
-	// offset helps us pick the right one for the given time.
-	// It's not perfect: during the backward transition we might pick
-	// either one.)
-	for i := range l.zone {
-		zone := &l.zone[i]
-		if zone.name == name {
-			nam, offset, _, _, _ := l.lookup(unix - int64(zone.offset))
-			if nam == zone.name {
-				return offset, true
-			}
-		}
-	}
-
-	// Otherwise fall back to an ordinary name match.
-	for i := range l.zone {
-		zone := &l.zone[i]
-		if zone.name == name {
-			return zone.offset, true
-		}
-	}
-
-	// Otherwise, give up.
-	return
-}
-
-// NOTE(rsc): Eventually we will need to accept the POSIX TZ environment
-// syntax too, but I don't feel like implementing it today.
-
-var errLocation = errors.New("time: invalid location name")
-
-var zoneinfo *string
-var zoneinfoOnce sync.Once
-
-// LoadLocation returns the Location with the given name.
-//
-// If the name is "" or "UTC", LoadLocation returns UTC.
-// If the name is "Local", LoadLocation returns Local.
-//
-// Otherwise, the name is taken to be a location name corresponding to a file
-// in the IANA Time Zone database, such as "America/New_York".
-//
-// LoadLocation looks for the IANA Time Zone database in the following
-// locations in order:
-//
-//   - the directory or uncompressed zip file named by the ZONEINFO environment variable
-//   - on a Unix system, the system standard installation location
-//   - $GOROOT/lib/time/zoneinfo.zip
-//   - the time/tzdata package, if it was imported
-func LoadLocation(name string) (*Location, error) {
-	if name == "" || name == "UTC" {
-		return UTC, nil
-	}
-	if name == "Local" {
-		return Local, nil
-	}
-	if containsDotDot(name) || name[0] == '/' || name[0] == '\\' {
-		// No valid IANA Time Zone name contains a single dot,
-		// much less dot dot. Likewise, none begin with a slash.
-		return nil, errLocation
-	}
-	zoneinfoOnce.Do(func() {
-		env, _ := syscall.Getenv("ZONEINFO")
-		zoneinfo = &env
-	})
-	var firstErr error
-	if *zoneinfo != "" {
-		if zoneData, err := loadTzinfoFromDirOrZip(*zoneinfo, name); err == nil {
-			if z, err := LoadLocationFromTZData(name, zoneData); err == nil {
-				return z, nil
-			}
-			firstErr = err
-		} else if err != syscall.ENOENT {
-			firstErr = err
-		}
-	}
-	if z, err := loadLocation(name, platformZoneSources); err == nil {
-		return z, nil
-	} else if firstErr == nil {
-		firstErr = err
-	}
-	return nil, firstErr
-}
-
-// containsDotDot reports whether s contains "..".
-func containsDotDot(s string) bool {
-	if len(s) < 2 {
-		return false
-	}
-	for i := 0; i < len(s)-1; i++ {
-		if s[i] == '.' && s[i+1] == '.' {
-			return true
-		}
-	}
-	return false
-}