time: add support for Plan 9

R=paulzhol, mirtchovski, r, r, rsc
CC=golang-dev
https://golang.org/cl/4362041

src/pkg/time/Makefile

@@ -13,17 +13,29 @@ GOFILES=\
 	time.go\
 
 GOFILES_freebsd=\
+	sys_posix.go\
+	zoneinfo_posix.go\
 	zoneinfo_unix.go\
 
 GOFILES_darwin=\
+	sys_posix.go\
+	zoneinfo_posix.go\
 	zoneinfo_unix.go\
 
 GOFILES_linux=\
+	sys_posix.go\
+	zoneinfo_posix.go\
 	zoneinfo_unix.go\
 
 GOFILES_windows=\
+	sys_posix.go\
 	zoneinfo_windows.go\
 
+GOFILES_plan9=\
+	sys_plan9.go\
+	zoneinfo_posix.go\
+	zoneinfo_plan9.go\
+
 GOFILES+=$(GOFILES_$(GOOS))
 
 include ../../Make.pkg

src/pkg/time/sys.go

@@ -4,10 +4,7 @@
 
 package time
 
-import (
-	"os"
-	"syscall"
-)
+import "os"
 
 // Seconds reports the number of seconds since the Unix epoch,
 // January 1, 1970 00:00:00 UTC.
@@ -52,11 +49,3 @@ func sleep(t, ns int64) (int64, os.Error) {
 	}
 	return t, nil
 }
-
-func sysSleep(t int64) os.Error {
-	errno := syscall.Sleep(t)
-	if errno != 0 && errno != syscall.EINTR {
-		return os.NewSyscallError("sleep", errno)
-	}
-	return nil
-}

src/pkg/time/sys_plan9.go

+// 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 (
+	"os"
+	"syscall"
+)
+
+func sysSleep(t int64) os.Error {
+	err := syscall.Sleep(t)
+	if err != nil {
+		return os.NewSyscallError("sleep", err)
+	}
+	return nil
+}

src/pkg/time/sys_posix.go

+// 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 (
+	"os"
+	"syscall"
+)
+
+func sysSleep(t int64) os.Error {
+	errno := syscall.Sleep(t)
+	if errno != 0 && errno != syscall.EINTR {
+		return os.NewSyscallError("sleep", errno)
+	}
+	return nil
+}

src/pkg/time/zoneinfo_plan9.go

+// 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.
+
+// Parse Plan 9 timezone(2) files.
+
+package time
+
+import (
+	"os"
+	"strconv"
+	"strings"
+)
+
+func parseZones(s string) (zt []zonetime) {
+	f := strings.Fields(s)
+	if len(f) < 4 {
+		return
+	}
+
+	// standard timezone offset
+	o, err := strconv.Atoi(f[1])
+	if err != nil {
+		return
+	}
+	std := &zone{name: f[0], utcoff: o, isdst: false}
+
+	// alternate timezone offset
+	o, err = strconv.Atoi(f[3])
+	if err != nil {
+		return
+	}
+	dst := &zone{name: f[2], utcoff: o, isdst: true}
+
+	// transition time pairs
+	f = f[4:]
+	for i := 0; i < len(f); i++ {
+		z := std
+		if i%2 == 0 {
+			z = dst
+		}
+		t, err := strconv.Atoi(f[i])
+		if err != nil {
+			return nil
+		}
+		t -= std.utcoff
+		zt = append(zt, zonetime{time: int32(t), zone: z})
+	}
+	return
+}
+
+func setupZone() {
+	t, err := os.Getenverror("timezone")
+	if err != nil {
+		// do nothing: use UTC
+		return
+	}
+	zones = parseZones(t)
+}

src/pkg/time/zoneinfo_posix.go

+// 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 "sync"
+
+// Parsed representation
+type zone struct {
+	utcoff int
+	isdst  bool
+	name   string
+}
+
+type zonetime struct {
+	time         int32 // transition time, in seconds since 1970 GMT
+	zone         *zone // the zone that goes into effect at that time
+	isstd, isutc bool  // ignored - no idea what these mean
+}
+
+var zones []zonetime
+var onceSetupZone sync.Once
+
+// Look up the correct time zone (daylight savings or not) for the given unix time, in the current location.
+func lookupTimezone(sec int64) (zone string, offset int) {
+	onceSetupZone.Do(setupZone)
+	if len(zones) == 0 {
+		return "UTC", 0
+	}
+
+	// Binary search for entry with largest time <= sec
+	tz := zones
+	for len(tz) > 1 {
+		m := len(tz) / 2
+		if sec < int64(tz[m].time) {
+			tz = tz[0:m]
+		} else {
+			tz = tz[m:]
+		}
+	}
+	z := tz[0].zone
+	return z.name, z.utcoff
+}
+
+// lookupByName returns the time offset for the
+// time zone with the given abbreviation. It only considers
+// time zones that apply to the current system.
+// For example, for a system configured as being in New York,
+// it only recognizes "EST" and "EDT".
+// For a system in San Francisco, "PST" and "PDT".
+// For a system in Sydney, "EST" and "EDT", though they have
+// different meanings than they do in New York.
+func lookupByName(name string) (off int, found bool) {
+	onceSetupZone.Do(setupZone)
+	for _, z := range zones {
+		if name == z.zone.name {
+			return z.zone.utcoff, true
+		}
+	}
+	return 0, false
+}

src/pkg/time/zoneinfo_unix.go

@@ -12,7 +12,6 @@ package time
 import (
 	"io/ioutil"
 	"os"
-	"sync"
 )
 
 const (
@@ -66,19 +65,6 @@ func byteString(p []byte) string {
 	return string(p)
 }
 
-// Parsed representation
-type zone struct {
-	utcoff int
-	isdst  bool
-	name   string
-}
-
-type zonetime struct {
-	time         int32 // transition time, in seconds since 1970 GMT
-	zone         *zone // the zone that goes into effect at that time
-	isstd, isutc bool  // ignored - no idea what these mean
-}
-
 func parseinfo(bytes []byte) (zt []zonetime, ok bool) {
 	d := data{bytes, false}
 
@@ -201,9 +187,6 @@ func readinfofile(name string) ([]zonetime, bool) {
 	return parseinfo(buf)
 }
 
-var zones []zonetime
-var onceSetupZone sync.Once
-
 func setupZone() {
 	// consult $TZ to find the time zone to use.
 	// no $TZ means use the system default /etc/localtime.
@@ -230,42 +213,3 @@ func setupZone() {
 		// do nothing: use UTC
 	}
 }
-
-// Look up the correct time zone (daylight savings or not) for the given unix time, in the current location.
-func lookupTimezone(sec int64) (zone string, offset int) {
-	onceSetupZone.Do(setupZone)
-	if len(zones) == 0 {
-		return "UTC", 0
-	}
-
-	// Binary search for entry with largest time <= sec
-	tz := zones
-	for len(tz) > 1 {
-		m := len(tz) / 2
-		if sec < int64(tz[m].time) {
-			tz = tz[0:m]
-		} else {
-			tz = tz[m:]
-		}
-	}
-	z := tz[0].zone
-	return z.name, z.utcoff
-}
-
-// lookupByName returns the time offset for the
-// time zone with the given abbreviation. It only considers
-// time zones that apply to the current system.
-// For example, for a system configured as being in New York,
-// it only recognizes "EST" and "EDT".
-// For a system in San Francisco, "PST" and "PDT".
-// For a system in Sydney, "EST" and "EDT", though they have
-// different meanings than they do in New York.
-func lookupByName(name string) (off int, found bool) {
-	onceSetupZone.Do(setupZone)
-	for _, z := range zones {
-		if name == z.zone.name {
-			return z.zone.utcoff, true
-		}
-	}
-	return 0, false
-}