Subversion Repositories openrisc

// Copyright 2009 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"

        "syscall"

)

// TODO(rsc): Fall back to copy of zoneinfo files.

// BUG(brainman,rsc): On Windows, the operating system does not provide complete

// time zone information.

// The implementation assumes that this year's rules for daylight savings

// time apply to all previous and future years as well.

// Also, time zone abbreviations are unavailable.  The implementation constructs

// them using the capital letters from a longer time zone description.

// abbrev returns the abbreviation to use for the given zone name.

func abbrev(name []uint16) string {

        // name is 'Pacific Standard Time' but we want 'PST'.

        // Extract just capital letters.  It's not perfect but the

        // information we need is not available from the kernel.

        // Because time zone abbreviations are not unique,

        // Windows refuses to expose them.

        //

        // http://social.msdn.microsoft.com/Forums/eu/vclanguage/thread/a87e1d25-fb71-4fe0-ae9c-a9578c9753eb

        // http://stackoverflow.com/questions/4195948/windows-time-zone-abbreviations-in-asp-net

        var short []rune

        for _, c := range name {

                if 'A' <= c && c <= 'Z' {

                        short = append(short, rune(c))

                }

        }

        return string(short)

}

// pseudoUnix returns the pseudo-Unix time (seconds since Jan 1 1970 *LOCAL TIME*)

// denoted by the system date+time d in the given year.

// It is up to the caller to convert this local time into a UTC-based time.

func pseudoUnix(year int, d *syscall.Systemtime) int64 {

        // Windows specifies daylight savings information in "day in month" format:

        // d.Month is month number (1-12)

        // d.DayOfWeek is appropriate weekday (Sunday=0 to Saturday=6)

        // d.Day is week within the month (1 to 5, where 5 is last week of the month)

        // d.Hour, d.Minute and d.Second are absolute time

        day := 1

        t := Date(year, Month(d.Month), day, int(d.Hour), int(d.Minute), int(d.Second), 0, UTC)

        i := int(d.DayOfWeek) - int(t.Weekday())

        if i < 0 {

                i += 7

        }

        day += i

        if week := int(d.Day) - 1; week < 4 {

                day += week * 7

        } else {

                // "Last" instance of the day.

                day += 4 * 7

                if day > daysIn(Month(d.Month), year) {

                        day -= 7

                }

        }

        return t.sec + int64(day-1)*secondsPerDay + internalToUnix

}

func initLocalFromTZI(i *syscall.Timezoneinformation) {

        l := &localLoc

        nzone := 1

        if i.StandardDate.Month > 0 {

                nzone++

        }

        l.zone = make([]zone, nzone)

        std := &l.zone[0]

        std.name = abbrev(i.StandardName[0:])

        if nzone == 1 {

                // No daylight savings.

                std.offset = -int(i.Bias) * 60

                l.cacheStart = -1 << 63

                l.cacheEnd = 1<<63 - 1

                l.cacheZone = std

                return

        }

        // StandardBias must be ignored if StandardDate is not set,

        // so this computation is delayed until after the nzone==1

        // return above.

        std.offset = -int(i.Bias+i.StandardBias) * 60

        dst := &l.zone[1]

        dst.name = abbrev(i.DaylightName[0:])

        dst.offset = -int(i.Bias+i.DaylightBias) * 60

        dst.isDST = true

        // Arrange so that d0 is first transition date, d1 second,

        // i0 is index of zone after first transition, i1 second.

        d0 := &i.StandardDate

        d1 := &i.DaylightDate

        i0 := 0

        i1 := 1

        if d0.Month > d1.Month {

                d0, d1 = d1, d0

                i0, i1 = i1, i0

        }

        // 2 tx per year, 100 years on each side of this year

        l.tx = make([]zoneTrans, 400)

        t := Now().UTC()

        year := t.Year()

        txi := 0

        for y := year - 100; y < year+100; y++ {

                tx := &l.tx[txi]

                tx.when = pseudoUnix(y, d0) - int64(l.zone[i1].offset)

                tx.index = uint8(i0)

                txi++

                tx = &l.tx[txi]

                tx.when = pseudoUnix(y, d1) - int64(l.zone[i0].offset)

                tx.index = uint8(i1)

                txi++

        }

}

var usPacific = syscall.Timezoneinformation{

        Bias: 8 * 60,

        StandardName: [32]uint16{

                'P', 'a', 'c', 'i', 'f', 'i', 'c', ' ', 'S', 't', 'a', 'n', 'd', 'a', 'r', 'd', ' ', 'T', 'i', 'm', 'e',

        },

        StandardDate: syscall.Systemtime{Month: 11, Day: 1, Hour: 2},

        DaylightName: [32]uint16{

                'P', 'a', 'c', 'i', 'f', 'i', 'c', ' ', 'D', 'a', 'y', 'l', 'i', 'g', 'h', 't', ' ', 'T', 'i', 'm', 'e',

        },

        DaylightDate: syscall.Systemtime{Month: 3, Day: 2, Hour: 2},

        DaylightBias: -60,

}

func initTestingZone() {

        initLocalFromTZI(&usPacific)

}

func initLocal() {

        var i syscall.Timezoneinformation

        if _, err := syscall.GetTimeZoneInformation(&i); err != nil {

                localLoc.name = "UTC"

                return

        }

        initLocalFromTZI(&i)

}

// TODO(rsc): Implement.

func loadLocation(name string) (*Location, error) {

        return nil, errors.New("unknown time zone " + name)

}